"This community exists to support people in their free software journeys. If you have questions about how a particular license works, or which to choose for your project, how to re-use software, advice on managing a healthy community, and so on, this is the place for you."

Nowadays, many people strive to conquer the heights of programming in one language or another. There are debates about which language is better, which is more productive, many developers and beginners focus on benchmarks and foam at the mouth to prove something to each other. This is so childish and so pointless!

Ask yourself the question, what will you create using this or that language? Do you have a startup idea? Can you create something new? Remake an existing one, but make it 10 times better?

If you are offered a job or take tests and interviews, you will be given technologies that you will be required to use. Business, money, and interests of managers who have never written code themselves will carry more weight than the results of your research and study of effective programming languages. This is the fucking reality of the industry today!

Therefore, you need to learn something else: physics, mathematics, chemistry, neurobiology, any natural science. This will give you the opportunity to write something in your favorite programming languages that someone else really needs. Not boring schedules and product lists, mailings and stores, fuck commerce.

Natural on, that's what should advance your programming knowledge!

When I come across such infographics with tips, I sometimes wonder, if you follow all these tips, then where will you find the time to program? Of course, all this is useful, but every developer knows how much you want to get done with all public affairs and immerse yourself in the code, especially if it is the code of a project that you love. And on the contrary, if you have to write a rotten project, with a stupid team, while working for a mercantile scumbag, no matter what you do, you will be sick of work. What is the conclusion here? Either you do what you love; or love what you do. And you will have much more free time. What about burnout? We are all phoenixes...

!

Almost 50 years ago, the C language defined modern computer programming. This book shows you why C is still as powerful and popular as ever, with an inside look at the new C23 standard.

For programs that need to be small, fast, and unfailingly reliable, C is still the gold standard. Whether you’re writing embedded code, low-level system routines, or high-performance applications, C is up to the challenge. This unique book by Jens Gustedt, a member of the ISO C standards committee, gets you up to speed with C23.

In Modern C, Third Edition you’ll:

• Learn C basics, core features, and advanced concepts
• Leverage major C23 improvements for security, reliability, and performance
• Write portable code that runs anywhere
• Build multi-threaded applications with atomics and synchronization
• Create robust and resilient software with error handling
• Use type-generic programming for reusable code

C powers more software than any other language — from embedded devices to distributed systems. In Modern C, Third Edition you’ll learn to harness C’s full potential using the latest tools and techniques. After a quick review of the fundamentals perfect for beginners or coders who haven’t used C in a while, this book guides you to mastery of C23, the latest ISO standard.

Rust coin must exist, otherwise what is the Rust compiler mining in the background?

Maybe you have to hear about this.

What do you think?

I think:

!C will never die

For infrastructure technology, C will be hard to displace. © Dennis Ritchie

Developers struggle with C pointers because they do not feel confident. I found a very good book about it: Understanding and Using C Pointers by Richard Reese.

"Why You Should Become Proficient with Pointers

Pointers have several uses, including:

• Creating fast and efficient code
• Providing a convenient means for addressing many types of problems
• Supporting dynamic memory allocation
• Making expressions compact and succinct
• Providing the ability to pass data structures by pointer without incurring a large overhead
• Protecting data passed as a parameter to a function

Faster and more efficient code can be written because pointers are closer to the hardware.

That is, the compiler can more easily translate the operation into machine code. There is not as much overhead associated with pointers as might be present with other operators.

Many data structures are more easily implemented using pointers. For example, a linked list could be supported using either arrays or pointers.

However, pointers are easier to use and map directly to a next or previous link. An array implementation requires array indexes that are not as intuitive or as flexible as pointers."

"A solid understanding of pointers and the ability to effectively use them separates a novice C programmer from a more experienced one. Pointers pervade the language and provide much of its flexibility. They provide important support for dynamic memory allocation, are closely tied to array notation, and, when used to point to functions, add another dimension to flow control in a program.

Pointers have long been a stumbling block in learning C. The basic concept of a pointer is simple: it is a variable that stores the address of a memory location. The concept, however, quickly becomes complicated when we start applying pointer operators and try to discern their often cryptic notations. But this does not have to be the case. If we start simple and establish a firm foundation, then the advanced uses of pointers are not hard to follow and apply.

The key to comprehending pointers is understanding how memory is managed in a C program. After all, pointers contain addresses in memory. If we don’t understand how memory is organized and managed, it is difficult to understand how pointers work. To address this concern, the organization of memory is illustrated whenever it is useful to explain a pointer concept. Once you have a firm grasp of memory and the ways it can be organized, understanding pointers becomes a lot easier."

---

Good explanation about "Differences Between Arrays and Pointers"

There are several differences between the use of arrays and the use of pointers to arrays. In this section, we will use the vector array and pv pointer as defined below:

c int vector[5] = {1, 2, 3, 4, 5}; int *pv = vector;

The code generated by vector\[i\] is different from the code generated by vector+i. The notation vector\[i\] generates machine code that starts at location vector, moves i positions from this location, and uses its content. The notation vector+i generates machine code that starts at location vector, adds i to the address, and then uses the contents at that address. While the result is the same, the generated machine code is different. This difference is rarely of significance to most programmers. There is a difference when the sizeof operator is applied to an array and to a pointer to the same array. Applying the sizeof operator to vector will return 20, the number of bytes allocated to the array. Applying the sizeof operator against pv will return 4, the pointer’s size. The pointer pv is an lvalue. An lvalue denotes the term used on the lefthand side of an assignment operator. An lvalue must be capable of being modified. An array name such as vector is not an lvalue and cannot be modified. The address assigned to an array cannot be changed . A pointer can be assigned a new value and reference a different section of memory. Consider the following:

c pv = pv + 1; vector = vector + 1; // Syntax error

We cannot modify vector, only its contents. However, the expression vector+1 is fine, as demonstrated below:

c pv = vector + 1;

There is a port hare-lang, but as Drew DeVault answered my question "Just want to know - is this port official hare distribution and is it updated?":

"We do not maintain downstream packages. It's official if that's an official source for your distro."

So I found a good manual on how to do this from repos:

There are 4 total things you need to install to get Hare working on FreeBSD, 2 pre-requisites and 2 Hare packages. It's possible that you already have the pre-requisites setup, in which case you can skip the step, but they are uncommon enough that I'm including them here.

I did the installation in a fresh jail for isolation, but of course you can install where ever you like, the steps are the same.

Initial setup

First you'll need git:

pkg install git

Since we're installing from source, we need somewhere to put the source, so I created /usr/local/src

mkdir -p /usr/local/src cd /usr/local/src

Now we can start building packages.

Pre-requisites

QBE

QBE is a compiler backend used by Hare.

First clone the repository:

git clone git://c9x.me/qbe.git cd qbe

Then build and install:

make make install cd ..

scdoc

scdoc is a man page generator, first clone:

git clone https://git.sr.ht/~sircmpwn/scdoc cd scdoc

scdoc uses syntax in its Makefile not supported by BSD make so you'll need gmake:

pkg install gmake

Then use gmake to build and install:

gmake gmake install cd ..

Hare

Now with the prereqs you can install Hare itself, first the bootstrap compiler:

git clone https://git.sr.ht/~sircmpwn/harec cd harec

Copy the FreeBSD config from the configs folder:

cp configs/freebsd.mk config.mk

Then build and install:

make make install cd ..

Last up is the main package:

git clone https://git.sr.ht/~sircmpwn/hare cd hare

Like last time, copy over the FreeBSD build config:

cp configs/freebsd.mk config.mk

Before building, Hare depends on as, an assembler, which you can get from binutils:

pkg install binutils

And with that you should be able to build and install:

make make install cd ..

Hello world

First, let's do a simple Hello world.

``` echo 'use fmt;

export fn main() void = { fmt::println("Hello world!")!; };' > main.ha ```

Which you can now run with the hare run command:

hare run main.ha

It will take a second the first time, but you should then see the print out. To build to an executable use the build command instead:

hare build -o helloworld main.ha ./helloworld

And that's it, I hope this is helpful for FreeBSD users out there.

What do you think about Hare? I think it takes best from different languages, intentionally or not...

It is simple like C, but safer, and at the same time allows you to shoot yourself in the foot to take control and make mistakes if you want.

Example from this blog post two years ago:

``` fn io::write(s: *stream, buf: const []u8) (size | io::error);

// ...

sum += match (io::write(s, buf)) { case let err: io::error => match (err) { case unsupported => abort("Expected write to be supported"); case => return err; }; case let n: size => process(buf[..n]); yield n; }; ```

Expression-based syntax and match statements remind me of Rust, but it implemented simpler without options...

Maybe you already used Hare in your project. Interesting to read your feedback...

Do you like it? Why?\ Dislike? Why?

Interview with the creator of the Hare programming language.

What does it mean?

How to properly install and set C debugging in Sublime Text?

Personally, I have nothing against the emergence of new programming languages. This is cool:

• the industry does not stand still
• competition allows existing languages to develop and borrow features from new ones
• developers have the opportunity to learn new things while avoiding burnout
• there is a choice for beginners
• there is a choice for specific tasks

But why do most people dislike the C language so much? But it remains the fastest among high-level languages. Who benefits from C being suppressed and attempts being made to replace him? I think there is only one answer - companies. Not developers. Developers are already reproducing the opinion imposed on them by the market. Under the influence of hype and the opinions of others, they form the idea that C is a useless language. And most importantly, oh my god, he's unsafe. Memory usage. But you as a programmer are (and must be) responsible for the code you write, not a language. And the one way not to do bugs - not doing them.

Personally, I also like the Nim language. Its performance is comparable to C, but its syntax and elegance are more modern.

And in general, I’m not against new languages, it’s a matter of taste. But when you learn a language, write in it for a while, and then realize that you are burning out 10 times faster than before, you realize the cost of memory safety.

This is that cost:

!

Why am I writing this post? Not because I hope for something or believe in change. These are just words. I could write this at the end, but then you would be looking for answers for me while reading, and I don't need them. They won't change anything.

So here it is. I don't claim to be a software development guru or a C language expert. I'm just a simple developer.

Why are we looking for new technologies? Why do we want to be part of a community that is buzzing with new projects? Why do we think that this new programming language will definitely help us create something amazing and truly great and, of course, will make us rich and provide us with a comfortable old age?

Why are we offered so many courses in so many programming languages and frameworks? Why do we teach what is required for companies that make money from us?

Why are there a lot of conferences on banal simple things, such as *** framework or ### technology (so as not to offend anyone), and there, with a smart look, newly minted gurus tell us how important it is to be able to transfer the value to the client and how to use certain templates?

Why do computers become more and more powerful, but programs continue to lag?

Why, when applying for a job, do we look for a vacancy based on knowledge of a programming language, but find it only based on knowledge of certain frameworks? Is it really difficult for a professional programmer to learn a framework in a week?

Why do we go into software development with the enthusiasm to create something great, but end up in a situation where we are developing some other catalog or some other digital yo-yo to make money?

Reason: because we want our passion for programming, our interest, to also bring us income.

Feature: we do not earn this money for ourselves, but for companies whose main goal is to quickly receive income from the software they sell.

Bugs: posts like this one.

There are a lot of questions and intentions to move into gamedev from developers who are burnt out at their jobs. And that's okay. From my own experience, I have a couple of pieces of advice that are not very professional.

1. It won't save you from everything you're so tired of.

Firstly, game development, like other areas, is full of its own nuances and pitfalls. And given that a person gets used to everything, you will soon find yourself in the same position. It’s better to look at game development as a hobby, a distraction from your main job. Moreover, for the first few years you will still not be able to earn enough to support yourself and your family.

2. There are no universal tools.

The main question in any field of programming today is which framework and programming language to learn. Here everyone will choose their own - what they can master. But it’s worth noting that in game development when switching, for example, from web development, you need to understand that you won’t be able to use React or even JavaScript if you want to become a real pro. You have to be willing to study hard. These are low-level languages - C, C++, Rust, and the basics of mathematics and physics, and possibly machine learning. It won't be easy, you just have to keep going. Take a break and study further. There is no need to strive to immediately choose the top and most complex tools; the main thing is to start somewhere.

3. This is a market with tough players.

If you think that you can create a game in a couple of months and immediately start making money, then this is not so. Of course, you can try, but the network is already full of low-grade content, and sometimes you just wonder about the mental health of the “creator”. I think it’s better to create one project, but ideal, adequate and interesting.

4. Hype is temporary, and you only live once.

Lots of technologies, engines, etc. surrounded by a lot of hype. This is not bad for the creators of these things, but if you run after the clouds, you will never get anything done. Let your achievements be modest, but they will be yours. This will save you from burnout at your main job, otherwise there will only be dissatisfaction with yourself.

Add your own...

Without any ::prelude and some void* arguments. Maybe you have thoughts about it.

The URL is just a sample of "why" but not "because".

I have my own preference but will keep it inside my mind to not burn a tornado that will erase me from the matrix of the world.

P.S.: I think C is faster, more powerful, and more elegant. I like it more than Rust.

!