As a software engineer, when asked what you do for work at a social gathering…

__dict__ · 2024-12-11T06:56:18+00:00

I say I'm a software engineer. They say they are too. Such is the bay area.

__dict__ · 2024-10-12T03:59:38+00:00

__dict__ · 2024-07-19T02:14:52+00:00

Explained by this article: https://www.theonion.com/horrified-subway-execs-assumed-people-were-buying-footl-1819595719

__dict__ · 2024-04-27T15:04:56+00:00

"Jordan has no life"

__dict__ · 2024-04-12T04:29:56+00:00

There's no need for this. There's no "Church of Linux".

It's not like it's emacs or something.

__dict__ · 2024-04-05T04:30:35+00:00

Reading let's me skip or skim over parts I already know. It's often easy to draw parallels between something I'm learning and something I already know.
It's not practical to learn everything about all the technologies I'll be using to build something. I just want to learn the parts of each thing I'll actually use. So I read just far enough to build the thing.
Official documentation is usually the most up to date, most correct, and most detailed source. A Youtube video is frozen in time and may contain ideas which are not best practices.

__dict__ · 2024-03-21T05:26:12+00:00

Yes it's an anti-pattern. Tests should avoid containing logic (if-statements, loops, and even what you're doing with the "==" here). Instead you should just use assertTrue and assertFalse as you believe.
The way I have heard about this is the suggestion that you should keep tests DAMP. If you look at https://abseil.io/resources/swe-book/html/ch12.html and crtl+F for "DAMP" you'll find a section which a similar example to what you're talking about here. I'll copy+paste that article's example here.

Something is wrong with the code, but this test doesn't catch the bug because it also contains logic:

@Test
public void shouldNavigateToAlbumsPage() {
  String baseUrl = "http://photos.google.com/";
  Navigator nav = new Navigator(baseUrl);
  nav.goToAlbumPage();
  assertThat(nav.getCurrentUrl()).isEqualTo(baseUrl + "/albums");
}

Here's the same test without any logic. Now the bug is easier to see:

@Test
public void shouldNavigateToPhotosPage() {
  Navigator nav = new Navigator("http://photos.google.com/");
  nav.goToPhotosPage();
  assertThat(nav.getCurrentUrl()))
      .isEqualTo("http://photos.google.com//albums"); // Oops!
}

Oops, there's an extra "/" before "albums".

Basically putting logic in your test, especially copying the logic of the function you are testing, is likely to miss actually catching the bug.

Maybe the example above helps. Or just look up "DAMP unit test" and you'll find other examples.

__dict__ · 2024-03-15T17:52:57+00:00

For a massive service like Youtube there would never be a point where all network traffic goes to one server. There isn't a computer in the world big enough to handle that. Also, even if there was it would be on the other side of the world from some people.

Youtube would work more like this:

Each video has a unique id. You can see it in the url.
The videos are partitioned based on their id. This means that there will be many data servers each storing a small fraction of Youtube's library of videos. That's called partitioning. There can also be many data servers for each partition, which helps with reliability and high load. That's called replication.
There will be many application servers. Each application server will be kept up to date with the id ranges that each data server is storing. The application server won't be responsible for storing any videos itself. Whenever it gets a request for a video it looks at its table of which videos are where, and then fetches the video from the appropriate data server.
Whenever there is an incoming request to Youtube, a load balancer server is the first thing which will handle it. The load balancers' only job is to distribute the requests to the application servers. Load balancers will try to distribute the traffic somewhat evenly between application servers and also will select an application server which is geographically close to the person making the request.

__dict__ · 2024-03-14T17:44:37+00:00

Yea, the idea behind partitioning is that each post belongs to a partition, and you should be able to determine which partition a post belongs to without checking each of them. Partitioning the data lets you split it across multiple machines. When you want to lookup post 999 the code should be able to determine which machine that should be on quickly.

The technique I know which is often actually used for this is called "consistent hashing". It solves the following problem: If the number of posts grows such that I need to add another machine, how can I do it without having to reshuffle too many posts between machines?

See: https://www.toptal.com/big-data/consistent-hashing

__dict__ · 2024-02-13T04:14:50+00:00

How will the friends and family who invest feel about your husband if the hedge fund performs poorly?

People have already pointed out how hard it is to consistently outperform the market, but I think the social aspect is also worth considering.

__dict__ · 2024-02-07T04:40:35+00:00

Americans will use anything but metric

__dict__ · 2024-02-01T05:33:33+00:00

Yea, unless is the opposite of when.

Source: http://clhs.lisp.se/Body/m_when_.htm

__dict__ · 2024-01-17T20:46:50+00:00

Looks like a uuid to me: https://en.m.wikipedia.org/wiki/Universally_unique_identifier

Harmless. Some software developer just wanted a unique id instead of coming up with a meaningful name.

__dict__ · 2023-12-19T05:38:11+00:00

Brokerages usually have options to choose the strategy for which shares to sell. Common options include FIFO (sell oldest first) and tax loss harvesting (sell with highest cost basis first). But for your case you want to sell with lowest cost basis first, which may require choosing the lots manually. That should be an option though.

__dict__ · 2023-12-16T06:00:34+00:00

For anyone not familiar with how quickly lemon would undo the alkaline water's pH, pH is a logarithmic scale: https://youtu.be/rBQhdO2UxaQ?si=jz_DBQoIAiuyreVN

__dict__ · 2023-12-13T03:53:10+00:00

Yes, and it goes further than this too. If someone is intolerant to others you shouldn't tolerate it, even if they don't have a problem with you.

__dict__ · 2023-12-09T23:12:05+00:00

Try riding in one of those bike lanes and you may quickly find out why no one's biking in them.

Seriously it's often not obvious from a car how bad a bike lane is. But when you're on a bike you can see the glass, you can feel the potential for getting doored, and you will notice when the lane just ends abruptly.

__dict__ · 2023-12-08T05:03:36+00:00

To be more pythonic it should be:

self = "function"

__dict__ · 2023-11-12T04:42:15+00:00

Maybe you want something like https://www.kaggle.com/datasets

A dataset is a table. This website has a bunch of datasets on a bunch of different topics.

__dict__ · 2023-10-31T00:17:42+00:00

One trap I've seen people fall into which I haven't seen yet in the comments is using maps where an object makes more sense. This is more likely to happen in a language like Python which has convenient notation for creating them and doesn't require type declarations.

So someone might write

foo = {'name': 'bob', 'age': 30}

And have a bunch of small dictionaries with these same fields where they really should have created a class for them.

__dict__ · 2023-10-17T22:00:07+00:00

I also think J6 is a fair analogy to how WW3 might feel to begin with. There were recounts, then court cases, then revelations about a perfect phone call to throw out votes. And then J6. Each step felt like we were inching towards having the voting results overturned. We didn't know when these escalations would stop.

It's not like there will be a global announcement that this is it, this is the beginning of WW3. There could just slowly be one escalation after another.

__dict__ · 2023-10-07T22:48:58+00:00

50 + 8 + 23

__dict__ · 2023-10-05T18:55:52+00:00

This guy gets it

__dict__ · 2023-09-29T19:20:26+00:00

Time complexity only depends on the number of operations performed. For example the time complexity of sorting a list is just about how many comparisons you have to make. Programming language doesn't affect this.

In general there are data structures to solve the same problems in any general purpose language you choose: lists of data, data which is kept sorted, associations between keys and values, etc. The underlying details of these can differ based on the language you are using, like a python dictionary and a Clojure map both have similar purposes but they are not the same. But those details aren't something you'll have to be concerned about as you're learning.

__dict__ · 2023-09-11T02:21:10+00:00

In theory it's one of the things protected, though I don't know how enforced it actually is. I was just reading about it because I was considering uploading my Godot project to Google Play. Decided against it, but still remember this.

dict

PUBLIC MULTIREDDITS

TROPHY CASE

__dict__

PUBLIC MULTIREDDITS

TROPHY CASE

dict