Programming

I am baffled any time I'm on facebook how horrid it is. Loads insanely slowly, won't accept picture uploads at random, randomly doesn't let you share to people in your friends group (it will just hide people for no reason). Such a terrible website. Sadly I have to stay on it for friends and music reasons (there is nothing else anyone I know uses) but man, it's crazy how badly they want you to install their spyware app so you don't use the browser version.

I have a vendor that sucks donkey balls. Their systems break often. An endpoint we rely on will start returning [] and take months to fix. They'll change a data label in their backend and not notice that it flows into all of their filters and stuff.

I have some alerts when my consumers break, but I think I'd like something more direct. What's the best way to monitor an external API?

I'm imagining some very basic ML that can pop up and tell me that something has changed, like there are more hosts or categories or whatever than usual, that a structure has gone blank or is missing, that some field has gone to 0 or null across the structure. Heck, that a field name has changed.

Is the best way to basically write tests for everything I can think of, and add more as things break, or is there a better tool? I see API monitoring tools but they are for calculating availability for your own APIs, not for enforcing someone else's!

Using the book Haskell Programming from First Principles by Christopher Allen, Julie Moronuki (https://haskellbook.com/)
Exercises are allowed to be used according to license

Come to my Discord to chat or bring up questions from the video
Discord server: https://discord.com/invite/r4pMZAuKGC
Donations are welcome at: https://ko-fi.com/ellyse7777

Feeling slightly exhausted by the world? Let's reverse a string in Rust in a needlessly complicated way. I was expecting to make a tiny simple video and ended up going further into unsafe than I ev...

cross-posted from: https://lemmy.ca/post/55368977

cross-posted from: https://lemmy.bestiver.se/post/745919

Comments

Fortunately, data demonstrates that making a better choice does not require daunting multiyear rewrites of existing codebases. Security can be dramatically improved by incrementally shifting the development of just new code to memory-safe languages. If these vulnerabilities can be avoided with low impact on other development goals, then choosing to introduce new ones should increasingly be considered unacceptable, and our goal should be for vulnerabilities to become increasingly impossible to introduce.

[...] This leads to a counterintuitive insight that defies some popular anecdotes: The most vulnerable code in your project is not some dusty legacy component, but the code being written today. This is because, like most bugs, vulnerabilities have a half life. The longer code exists and is exercised, the more likely its flaws are to be found and fixed, leaving the freshest code with the highest concentration of bugs.

[....]

Beyond stability, there have also been gains in development velocity. Change lead time, the time it takes for a code commit to be successfully deployed, is a critical measure of efficiency. One of the largest factors in this metric is often code-review latency. Our data shows a fascinating trend: As our developer community has gained experience with Rust, the time required for code reviews has decreased (see figure 4b). Rust changes tend to go through fewer revisions and spend less time in the review cycle, with an approximately two times faster median code review in 2024 compared with C++.

[...]

These positive outcomes demonstrate that choosing a memory-safe language is not about making a tradeoff between security and productivity. We are not sacrificing quality for velocity or productivity for security. We are improving across all of these metrics simultaneously. The results were achieved while reducing costs associated with sandboxing, fuzzing, and the engineering hours spent triaging and patching bugs. Using a better tool allows for fewer tradeoffs, resulting in better software and, ultimately, a better product.

Dr Iain McGilchrist paints a stark moral and existential picture of where AI is heading, and how this is preceded by and furthers a dangerous shift in our brains to a focus on power.

cross-posted from: https://jlai.lu/post/28733131

While looking around for datepicker libraries, I came across this helpful guide on how you can use native datepickers for most, if not all, required datepicker functionality. Sure, it may not be as flashy as the JS enhanced or framework alternatives, but still worth considering IMO.

The description listed a mirror of this video on Vimeo, but I'm not sure if it's still accessible as I have no access to Vimeo here: https://vimeo.com/649009599

Recently I discovered something called data-oriented design and I thought it was such a brilliant concept. Here are other references I recommend:

• A book available online freely https://www.dataorienteddesign.com/dodbook/
• I think this is the first blog post about the concept https://gamesfromwithin.com/data-oriented-design
• Data-Oriented Design and C++ - A talk by Mike Acton https://www.youtube.com/watch?v=rX0ItVEVjHc

What's new in .NET 10

.NET 10 is a LTS (long term support) release.

With C# 14, F# 10, .NET Libraries, ASP.NET Core, Blazor, .NET MAUI, Entity Framework Core 10, Visual Studio 2026, SDK releases.

This post is part of my series comparing C++ to Rust, which I introduced with a discussion of C++ and Rust syntax. In this post, I discuss move semantics. This post is framed around the way moves are implemented in C++, and the fundamental problem with that implementation, With that context, I shall then explain how Rust implements the same feature. I know that move semantics in Rust are often confusing to new Rustaceans – though not as confusing as move semantics in C++ – and I think an exploration of how move semantics work in C++ can be helpful in understanding why Rust is designed the way it is, and why Rust is a better alternative to C++.

When publishing a package for use by programmers, automated changelog generation is very beneficial. In this blog post, I explore how to do it in a simple way that works everywhere.

JPlus is fully compatible with Java, offering modern language features like null safety, boilerplate code generation and other modern language features to reduce developer burden and maximize productivity.

Notably, there is currently no ‘superset’ language that keeps Java syntax almost intact while extending the language with features like null checks at the language level. JPlus aims to fill this gap, providing a language that existing Java developers can naturally learn and adopt.