AugustoCAS

Google makes money, so they are happy to look away. The scams (e.g. Mr Beast fake video) are identical so it would be trivial to automatically kick them from the platform. The crypto bro's ads are also pretty much identical.

The crypto bro ads are hilarious and it looks like they all use the same platform. I wonder if all of them are part of a ponzi scheme in which someone sells a course to sell crypto courses.

Something I do, which is a bit silly, is to click the ad just to burn money from the scammers.

I do agree with a lot of the presentation. A word of caution though: some technologies that start by offering simplicity evolve over time to provide a very difficult to grok environment. So the evaluation about the cost of maintenance is not a do once and forget.

And sometimes boring means roll your own. An important aspect of this for me is to pick the simplest solution: A bit of code > A library > A Framework > Platform, which I think is in line with the presentation.

I cannot say about the US, but Python & Pandas are quite sought after in Europe.

I wonder if the problem is that you have to find the first role in order to show that you have some actual & recent, on-hands experience. I've heard other people coming back to work with similar stories (in wildly different industries).

I think the suggestion of working for a non-profit is quite good. I would also suggest you to network; go to meetups in your area as that will potentially put you in front of people who are responsible for hiring.

I've seen this on the org I work, the whole 'engineer manager' layer was removed and replaced with wishful thinking (love that phrase!). The engineer managers had a good idea of how to manage teams and were doing team/tech lead work and coaching the team/tech leads, which didn't have much experience (mostly senior devs who didn't want to code any more).

This org in particular missed, in my eyes, where to cut. There is a number of engineers who cannot do much more than copy/paste code and the org has no wish to train them. Unfortunately, the org thinks that going wide (lots of teams, lots of people) is a good way to scale.

Whomever at FF came with the text on that page deserves a raise:

hello :teapot: -> bonjour :baguette:

HN unfortunately removes the emojis.

I'm going to use that title on the next conversations I have about estimates, in particular in the context of 'we need to know that this piece of work will be started in 4 months and finished in 8'. Those conversations definitely ſuck for me.

Part of me agrees, another strongly disagrees. Refutation works in a rational society, and we don't live in one.

Quoting the fantastic Terry Pratchett: "A lie can run round the world before the truth has got its boots on."

This has a few consequences: 1) Most of the damage is done. 2) Correcting the lie/misinformation takes a lot more effort that it takes to spread the lie. 3) The lie/misinformation can cost lives (missinformation on vaccines, coloidal silver, etc)

It doesn't help that some people and publications make money by selling lies and inflaming people (tabloids, many 'influencers', etc). And also that some supposedly respected institutions are often the originator of those lies (e.g. health risks of smoking, excess sugars, etc)

Thanks for sharing this. A few family members consume a good amount of alternative medicine without any idea of what they consume as the products are not regulated, or they source products from places that make no claims that are for human consumption.

If I had any Delphi books, I would put them next to my copy of Learn Sumerian in 24 Hours.

I disagree, I just left a company in which most teams 'modularized' their code in the way Parnas describes as not ideal. What Parnas describes are low level modules that are now mostly provided by languages, but the same applies to 'business' modules. In the org I left, minor changes in a microservice had wildly unexpected consequences due to a mix of lack of information hiding coupled with large data objects. One example: storing a debit in an account would become a credit when loaded back under some circumstances.

The mentality of most developers there was: How can I make the change described in the ticket by touching as little existing code as possible?

Maurizio Cimadamore, the project Owner, recently did a presentation on Project Panama (this JEP) during the JVM Summit 2023 - https://www.youtube.com/watch?v=kUFysMkMS00

This JEP will be in preview in Java 21 and the plan is to finalise it by Java 22. So it will be another ~2 years until it is part of an LTS release.

Just to join the chorus (as I'm listening to Agnus Dei by Barber)

Firefox + uBlock Origin (too lazy to use uMatrix) + privacy badger (because why not) + multi account containers + User agent switcher (for sites which want something else and refuse to load on FF, e.g. bing chat)

Fully agree on this, plus (a very important plus) test that severing down an AZ doesn't bring the services on the good AZ down too. And test this frequently.

I would be very, very surprised if the companies mentioned, in particular banks, weren't running on multiple AZs, but I wouldn't be surprised if the scenario of severing down an AZ was not tested.

I'm slowly grokking Haskell and I like the genius (or madness?) of having the type system do a lot to verify that the program is correct.

I just started reading about liquid types and I'm loving the idea : https://news.ycombinator.com/item?id=37349276

The answer to your scenario is `yes` with a high probability (taken from my magician's hat), but only in the short term.

People like the one described in the article prepare a pipeline of good engineers, who also have experience in the domain and in the organization.

So if one cares about fast delivery, get a good number of sr engineers who work on their own thing, share little and are not encumbered by each other. If a company needs to deliver urgently this works, but is an (expensive, short term) option.

This is huge. Yesterday The Register published an article [1] mentioning that Qakbot was responsible for 30% of recorded intrusion attempts since the start of 2023.

[1]: https://www.theregister.com/2023/08/28/top_malware_loaders/

I've been enjoying learning Haskell for the last 6 months and one of the things that I really enjoy is learning new algorithms that use functional approaches (and use immutable data structures).

Coming from a Java background, where most data structures are mutable (lists, maps/sets, trees, etc) finding how the same problems are used with immutability is quite mind expanding (height balanced trees, rose trees, finger trees, etc) and how some other algorithms are impractical and expensive (e.g. bubble sort).

F# is gorgeous. For anyone dipping their toes into functional programming, the book Domain Modeling Made Functional by Scott Wlaschin [1] does a great job to get the basics of F# and, more importantly, how to use a functional, strongly-typed language to model a domain for business applications.

[1]: https://pragprog.com/titles/swdddf/domain-modeling-made-func...

I assume you were using AWS? I know some of the AZ of other cloud providers (Azure? Oracle? Google?) are not fully siloed. They might have independent power and networking, but be in the same physical location.

I'm mentioning this for other people to be aware as one can easily make the assumption that an AZ is the same concept on all clouds, which is not true and painful to realise.

About youtube-dl, I think the version in pip is about a year old. For now the best way is to get the code and build it (which is just to run `make`)

The best way is to download the source from github, run `make`, and copy the the file to $HOME/bin . There hasn't been a release for about a year now and the files on the distro repos are even older (I think).

Also YouTube has been doing some changes lately on the the player and a lot of the tools fail to download audio or video.

For example, in the last couple of weeks there have been some issues with a redirect to a 'consent page' : https://github.com/ytdl-org/youtube-dl/issues/32499

I agree with you. MS can be a solution to a few problems, and as you mentioned 'do one thing and do it well' is not one of them.

In my head MS works well for - Teams with different approaches. - Different tech stacks

I cannot think of another good reason in which MSs would be a better solution than a good monolith (and communication).

I think this is an oversimplification. Having something that does one thing and does it well works for simple things that can be composed. Sometimes this is not the case, as the composition would be too cumbersome or too slow.

The example of Obsidian (in my eyes) confirms this. Markdown is a very simple and elegant way to produce simple documentation, but as soon as one needs more it just crumbles.

I agree that the big tools (Word, excel, photoshop, etc) are bloated. These applications have crossed the bridge into 'they do everything about X' long time ago and they work well in their very wide problem space. Just taking excel (or Calc) as an example, I cannot see how using simpler tools I could create pivot tables and aggregate values across multiple sheets.

The author of this blogpost presented it a couple of days ago on Functional Programming Sweden:

How APL made me a better Python developer by Rodrigo Girão Serrão: https://www.youtube.com/watch?v=tDy-to9fgaw

I started learning haskell about 6 months ago and I'm quite enjoying it as it requires a different mental model compared to any C-like language (Java, C#, etc).

Learning Haskell has helped me to cut a good amount of BS from technologies (and engineers too). Haskell needs Monads, Transformers and more things that I don't understand yet because sometimes operations need to be sequenced. And on top of it because it's not possible to perform any non-deterministic (IO) action without telling the world about it, as any non-deterministic behaviour is wrapped in IO.

I also find it interesting that Haskell feels lot more polymorphic that every statically typed OO language I know, when polymorphism is one of the pillars of OO.

You have to build it from source to avoid the 60kbps limit. There hasn't been a release since Dec 2021 and there have been some updates since then that implement the 'puzzle' to get the right value of the url parameter.

It's worth noting that YouTube is trialling a new player and a lot of applications (invidious, new pipe, etc) are experiencing some issues in the last couple of weeks.

I relate to this too. I spent a year in a company were I was hired to kickstart their technology department but the CISO actually wanted to outsource development (he used to be employed by the outsourcing company, what a coincidence!). Then I made a mistake of joining a fintech scale up that run like a body shop. Both places were very frustrating for me and tilted me into a burn-out (or even mild depression?) similar to what you describe.

For a bit more than year the only thing I could read was science fiction books, when I would usually read ~20 technical books a year and do multiple courses. For a while I even thought I had somehow got ADHD as I couldn't focus.

I came out from that about 6 months ago and I'm slowly coming back to my 'normal'. I put myself the objective of learning Functional Programming and just finished a couple of beginner Haskell books and courses, which I found quite refreshing.

TL;DR The EU is working on the Cyber Resilience Act (CRA) which will be voted on the 19th of July. The current wording makes it look like it will affect open source projects that receice donations; which have contribution from corporate developers; and might break coordinated vulnerability disclousure.

If you live in the EC area, there's a link on the blog to contact to MEP.

The blog also links to other posts from OSS organisations sharing the same concer.

* https://blogs.eclipse.org/post/mike-milinkovich/european-cyb...

* https://pyfound.blogspot.com/2023/04/the-eus-proposed-cra-la...

* https://blog.opensource.org/the-ultimate-list-of-reactions-t...

I recently escaped an organization that had a couple of apps built using this approach everywhere but for the opossite reason stated in the article. The team wanted to write code in a functional way in Java because _FP is better than OO_.

Most (if not all) classes had a single method and implemented BiFunction. The app was wired with Spring... if you had the bad luck of using Spring you can get the idea of how ugly this was. All method invocations were `apply`s and navigating the code was as easy as finding a needle in a haystack in the middle of the night. A good amount of the wonderful features of a tool like IntelliJ couldn't be used.

My rule of thumb is to follow the grain of the language / framework / library as to produce as little surprise to other devs.

It's not an antipattern and it will never be. Like many solutions there are scenarios in which using an ORM is the simplest thing to do.

Also there are many different implementations of ORMs each with different features (Martin Fowler has a list from his Patterns of Enterprise Application Architecture: https://www.martinfowler.com/eaaCatalog/index.html). For example in the JVM world, jOOQ and Hibernate provide very different solutions.

* jOOQ provides a table data gateway (when used without records)

* Hibernate: unit of Work, Lazy load, multiple inheritance strategies, Query object, Versioning, lifecycle events, and much more. Lot of the grief about Hibernate comes mainly from people who never bothered RTFM.

Having said the above, if one needs flexibility and high performance (with complex queries), using vanilla SQL is invariably the best way.