/prog/ - Programming

>>3589

>fucking hate falsiness

>null should be falsy

I hate gets() and scanf(). In CURRENT_YEAR, these libc functions should do nothing but cause a compile-time error, telling you to use shit that isn't fundamentally insecure (in the case of gets) or fundamentally incapable of interacting reasonably with a user (in the case of scanf). Read in lines at a time, into buffers that can contain those lines, and use sscanf() on read lines if you really want that shit.

I hate how every 'modern' 'advanced' 'high-level' programming language is stuck in the 90s. The Linux kernel continues to advance. It has all kinds of cool system calls. You can do shit like swap the names of two files without a race condition. But fuck it, Windows doesn't have that, and it wasn't portable among unices back in 1995.

oops that second one wasn't a future.

Replacement hate: laziness.

It is the solution for literally nothing, but it introduces all kinds of problems of its own.

>>3722

Null being falsy is unambiguous in almost every case.

>waah waah languages arent 100% theoretically correct

Fucking pretentious losers in this thread, what have you accomplished besides bitching?

https://en.wikipedia.org/wiki/Parkinson%27s_law_of_triviality

Go and write something more complex than "hello world" to have some weight behind your words before you act like a software god. Your code probably runs like shit, and that's not because gets() and scanf() suck, >>3722

>>3728

I'm a professional programmer who has to use dozens of languages through work; you get a long list of things to hate when you have to use tons of different languages in codebases written by other people.

Why are you afraid that people might actually learn something and improve?

You can't really invoke Parkinson's Law of Triviality here, given that what we're talking about are basic programming features that affect every aspect of the language. That's the opposite of the Law of Triviality.

I look in the mirror and realize I won't be getting laid without being successful.

>>3674

i know that feel

>>3672

inspiration: noobody.org

Read about mathematical concepts, watch conference talks.

Occasionally a variation of this >>3674

I just have a vision in mind, and then go do it. I've never looked at anyone else's code. I've consistently ignored anything anyone says about "good" or "bad" languages, practices, anything. I just focus on my project, not worrying if I'm doing something in a "bad way" or any other distractions. That is all the "inspiration" I need.

3d space or 2d space? Do you actually mean lines or line segments?

If 2d space, just check the slope. They intersect if they aren't parallel.

In 3d space, calculate their closest points. They intersect if their closest point is equal.

>>3095

something something vectors.

https://www.cs.utah.edu/~jsnider/SeniorProj/BSP1/default.html

has some code that might help you, such as methods that determine wether a point is in front of or behind a plane.

>>3095

https://web.stanford.edu/~liszt90/acm/notebook.html#file8

Think of it like back in highschool algebra.

y=mx+b

if line 1 line 2

collision == true

>>3685

what about vertical lines?

it make a me feel gooot

>>3651

In C++, objects and structs are the same thing. struct and class are synonyms; it's valid C++ for a struct to have methods.

>>3639

There's a decent amount of research into that, the minimum required for turing completeness. Also a common theme in esolangs. Binary combinatory is pretty fuggin simple, le copy-paste from http://esolangs.org/wiki/Binary_combinatory_logic

Binary combinatory logic

Binary combinatory logic (BCL) is a complete formulation of combinatory logic (CL) using only the symbols 0 and 1, together with two term-rewriting rules. BCL has applications in the theory of program-size complexity (Kolmogorov complexity).

Contents

Definition

Syntax

<term> ::= 00 | 01 | 1 <term> <term>

Semantics

Rewriting rules for subterms of a given term (parsing from the left):

1100xy → x

11101xyz → 11xz1yz

where x, y, and z are arbitrary terms.

(Note, for example, that because parsing is from the left, 10000 is not a subterm of 11010000.)

The terms 00 and 01 correspond, respectively, to the K and S basis combinators of CL, and the "prefix 1" acts as a left parenthesis (which is sufficient for disambiguation in a CL expression).

There are four equivalent formulations of BCL, depending on the manner of encoding the triplet (left-parenthesis, K, S). These are (1, 00, 01) (as above), (1, 01, 00), (0, 10, 11), and (0, 11, 10).

>>3639

This isn't exactly what you're asking, but I prefer lambda calculus to a turing machine.

https://en.wikipedia.org/wiki/Lambda_calculus