The Big Programming Thread - Page 990

On January 16 2019 07:11 travis wrote:
Given a 2d point, and a distance, I would like to output a point every 10 degrees on the circle that surrounds that point by the distance. It can start at 0 degrees, I don't really care. So, 35 points.

What is a good way to do that? Brain is pretty tired. I am using python but I am sure I could convert non python code to python if you want to write it in your favorite language (without relying on libraries).

circle(Point point, int dist) {
	Point [] circle = new Point [36];
	for (i=0;i<36; i++) {
		circle.add(new Point ( point.x + dist*cos(i*10), point.y + dist*sin(i*10));
	}
	return circle;
}

On January 20 2019 02:13 WarSame wrote:
I asked my coworkers and apparently they announced something like a Simple Http Operator at ReInvent. We're going to use Lambdas for now.

Also, no programming language should have breaks, jumps, or continues. CMV.

On January 20 2019 07:03 travis wrote:
I agree about breaks and continues.. I rely on them constantly, especially continue.

Using "if X, continue" can replace an "if A or B or C or D or E or F or G... etc"

On January 20 2019 19:47 SC-Shield wrote:
When a guy like Bjarne Stroustrup (C++ inventor) is hesitant to give hard rules about not using something in C++ because he says that there are exceptions, I think not many people are around his level to be so sure to advise against using something in programming ever. You could be talking about a different programming language, but I think this idea still aplies.

For example, C++11 has smart pointers which deallocate memory based on scope.
E.g.

void SomeFunction()
{
    std::unique_ptr<Class> object = std::make_unique<Class>(constructor parameters here);
}    // memory is deallocated when function's scope ends

The usual advice is not to use "new" and "delete" anymore to reduce the chance of memory leaks. This isn't a hard rule because you still need "new" and "delete" even with smart pointers. For example, when you need a custom deleter function and one case for that is if you work with C implementation of something. So, "new" and "delete" are still useful, you just need to use them less but giving a hard rule not to use them at all is meaningless when you don't have context. I think it's more important to understand *why* before learning a rule so you know when not to apply it.

On January 15 2019 22:49 ZenithM wrote:
Even assuming AI is indeed the future, AI jobs are a bubble right now, but it will plateau or even dial down at some point. Having basics in machine learning will be very common for every scientist or programmer, but we don't need that many people working on data.

And like everything else, there is a spectrum of skill and expertise within AI/ML, after a while it won't be worth much to put that on your CV if all you did was take a class.
I would say at this very moment it indeed looks good on your CV though. Even small businesses are looking for a dedicated "data scientist" even if they don't realize they need one full-time guy to do that.

On January 20 2019 08:17 tofucake wrote:
Break and continue are amazing, especially in batching. People who say to never use them and to just design stuff "better" are wrong.

On January 20 2019 22:54 SC-Shield wrote:
Do you guys know a good article to read about POSIX concurrency (threads and synchronisation) as well as signals? If not, I'll just stick to what I've found on Google so far.

On January 22 2019 01:15 Mr. Wiggles wrote:

Not an article, but the book "Advanced Programming in the UNIX Environment" by W. Richard Stevens has a very good treatment of many UNIX systems programming concepts. There's an entire chapter on each of the subjects of signals, threads, and thread control.

I believe there's source for the book available so you can theoretically make your own PDF if you don't want to buy it.

http://www.apuebook.com/apue3e.html

On January 21 2019 06:01 WarSame wrote:

How so? Where would you reasonably use them that using sub functions wouldn't work so well and be much clearer?

outer loop
  outer a

  inner loop
    inner a

    if condition
      continue outer (without going to outer b)

    inner b

  outer b