Hi all,

A fair while ago I asked the community here advice as my 8yo lad wanted to experiment with programming: Old Post.

Thanks so much for all the words of wisdom - there’s still stuff we can explore in the replies.

Thought I’d just give a little update.

So I installed dual boot Linux Mint / OSX on an old intel MacBook Air (dual boot in case his homework/school stuff needs it, but he hasn’t used OSX much!).

It was much easier than I thought it’d be. Perhaps it’s just the hardware/OS choice, but I don’t consider myself to be ‘properly’ technical and it was a breeze. Perhaps the only difficult part was creating a bootable OSX restore disk just in case I destroyed the OS… it’s almost like Mac really don’t want you to be doing this.

He’s working his way through foundational courses on programming, in codeacademy, and using scratch as usual. So far, so good.

Is there an IDE you’d recommend that has some element of a tutorial to it?

While learning Automata and computation theory independently, I made a realization I want to confirm.

Regular languages can all be created by taking elementary languages (languages made up of a single member of its alphabet) and performing closed operations in them, such as union, concat, and kleene star. This was clear to me from regular expressions.

Is this true? Is there any significance to this fact?

What about Context-free languages and other formal languages? Are there operations that can be performed on elementary languages to create all of them? Or is this a special property of regular languages only?

Hey all, I wrote this article with some practical advice on how to resist the attention economy (think notifications, shorts, ads, etc) by setting up a desktop for mindful engagement.

It also includes a VirtualBox VM with a lightweight sample environment so you can try it out and see what I mean in the article.

Hope this is helpful! :)

I want to create an AppImage of my Python software and distribute it this way. The script will be compiled with Nuitka to include Python and Standard Library functionality. In the AppImage I want to bundle it with other Libre software, but in binary format downloaded from Arch package repos, as my script depends on them. My script is more like a complex automation tool. I do not make any changes to the code of these binary dependencies, just include them as they are.

I don't know how to deal with the licenses. Do I have to include the license for every project in my AppImage? Do I have to put the source code of these projects in it too?

Hacker news discussion - https://news.ycombinator.com/item?id=39600810 Radicle source code - https://app.radicle.xyz/nodes/seed.radicle.garden/rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5

I wanted to take a different spin on offering career advice to software engineers. I thought it could be an interesting exercise to share several big lessons from my ~12 years of managing software engineers and transform those lessons into actionable advice.

The first 8 years of my professional career after university were managing software engineers, but I was also a contributing software engineer myself. It was difficult to balance (especially at a rapidly growing startup), but the experiences from both IC and Management perspectives were very helpful.

I hope you find value in this! TP;DR at the top of the post.

I was reflecting today on how many powerful ladies I'm blessed to work alongside on my team.

I know there's often a sentiment that women in our industry are under appreciated or not given enough credit. So to whom it may concern: thank you for all you do!

For non-trivial reviews, when there are files with several changes, I tend to do the following in Git:

1. Create local branch for the pr to review
2. Squash if necessary to get everything in the one commit
3. Soft reset, so all the changes are modifications in the working tree
4. Go thru the modificiations "in situ" so to speak, so I get the entire context, with changes marked in the IDE, instead of just a few lines on either side.

Just curious if this is "a bit weird", or something others do as well?

(ed: as others mentioned, a squash-merge and reset, or reset back without squashing, is the same, so step 2 isn't necessary:))

So I am not a professional programmer, but I do like to tinker with projects and just teach myself stuff (in python and now rust). I currently just install stuff on my linux distro off of the repos or anaconda for python. I've never had any particular issue or anything. I was thinking about maybe moving projects into a container just so that they are more cleanly separated from my base install. I am mostly wondering about how the community uses containers and when they are most appropriate and when they are more issue than they are worth. I think it will be good for learning, but want to hear from people who do it for a living.

I'm working on a client library in Typescript that's a re-implementation and extension of another client library. The reason for this is so the client library can be licensed the same as the rest of the project (MIT) since the original library is AGPL. I'm good with that part, and it's just background info.

The question I have is how to handle the type declarations. In order to be a drop-in replacement, the client code would expect the library's exported types and their names to be the same.

I know header files are considered non-copyright-able (Oracle v Google), so it seems to me that the type declarations would also fall under that umbrella. I've not found anything definitive (yet) that covers those, but they seem analogous.

Is that a safe assumption?

I want something that is:

• SSG (static site output)
• looks nice
• is a template I can use out of the box by just dropping in my content and configurations, rather than designing or building myself
• is not feature-poor. I want it to have features like footnotes, jump-to-section links, citations, on-hover pop-ups for citations or footnotes, syntax highlighting for code blocks, etc.
• nice to have: ability to draw basic graphs or diagrams (helps in technical explanations)
• is not too difficult to customize by editing the code directly, Customizing the looks, structure, or adding functionality if I needed

Programming language doesn't matter much. I can use whatever. I do have a preference for functional languages.

Eleventy seems like a great framework to do this, but as I said I want a template that's ready out of the box not just a framework. The blogging template I found for eleventy does not look as nice as I hope.

There's a lot, and specifically a lot of machine learning talk and features in the 1.5 release of Opus - the free and open audio codec.

Audible and continuous (albeit jittery) talk on 90% packet loss is crazy.

Section WebRTC Integration → Samples has an example where you can test out the 90 % packet loss audio.

Suppose we have a large to-do task manager app with many features. Say we have an entity, which is the task, and it has certain fields like: title, description, deadline, sub-tasks, dependencies, etc. This entity is used in many parts of our codebase.

Suppose we decided to modify this entity, either by modifying, removing, or adding a field. We may have to change most if not all of the code that deals with this entity. How can we do this in a way that protects us from errors and makes maintenance easy?

Bear in mind, this is just an example. The entity may be something more low-key, such as a logged user event in analytics, or a backend API endpoint being used in the frontend, etc.

Potential Solutions

Searching

One way people do this already is by just searching the entity across the codebase. This is not scalable, and not always accurate. You may get a lot of false positives, and some parts of the code may use the entity without using it by name directly.

Importing

Defining the entity in one central place, and importing it everywhere it is used. This will create an error if a deleted field remains in use, but it will not help us when, say, adding a new field and making sure it is used properly everywhere the entity is being used

so what can be done to solve this? plus points if the approach is compatible with Functional Programming

Automated Tests and CICD

Tests can discover these types of issues with high accuracy and precision. The downside is... Well tests have to be written. This requires developers to be proactive, and writing and maintaining tests is non-trivial and needs expensive developer time. It is also quite easy and common to write bad tests that give false positives.