Ask HN: Improve C language skills after K&R?

Help somebody else learn C.

Start learning 8086 or more commonly known a x86 Assembly... That will get you much closer to the hardware and will give you entirely new sets of problems to solve and an immense knowledge of how computers work.

Guaranteed to make you a better software engineer.

Personally, I've always enjoyed doing low-level programming. You may consider looking at writing homebrew games for older consoles, or OS development. Both of those would require you to expand your C skills, and would give you an intimate understanding of how computers work.

You could try to make a non-trivial application in C, such as something using IPC / sockets. You could try to make a game. You could try to make a UI application using GTK or similar UI framework. You could start contributing to an open source project (there are so many official GNU C projects). You could try to write a server that implements a simple protocol from the RFC (such as socks5)[0].

Also look into C build systems like cmake or autotools.

[0] https://www.ietf.org/rfc/rfc1928.txt

I would love feedback on this. I wanna take a secure software design course and my C is lacking. Everyone recommends Learn C the Hard Way.

http://c.learncodethehardway.org

tptacek, who is obviously hot stuff here on HN for his infosec knowledge, recommends this book on Amazon favorably on his recommended InfoSec reading list.

C Interfaces and Implementations: Techniques for Creating Reusable Software

https://www.amazon.com/review/RMXKDJNH8UOPU/ref=cm_cr_dp_tit...

He said it is the most advanced C book in existence. If only I had enough time to not only read but understand it all! Haha.

Make sure you have a good understanding of the standard library - in C, this should not be thought of as a black box (because, unlike in some languages, it is written in the language itself, and also it's rather small and minimal).

You should familiarize yourself with the source for a C standard library (not necessarily the one your're using, maybe uclibc, something simple), and work towards being able to implement the functions yourself. For some functions like malloc(), printf(), etc, understanding the implementation tradeoffs will help you understand problems with your own code.

The book: Expert C Programming: Deep C Secrets by Peter Van der Linden

This book is great, full of good code and even better writing.

handmade hero[0]! Casey Muratori records many hour long sessions where he goes through the steps of making a video game from scratch in C. Practical, hands on experience from a guy who knows his stuff.

[0]: https://handmadehero.org/

The Peter van Linden book: _Expert C Programming_ is old but nice:

https://www.google.com/search?q=expert+c+programming+deep+c+...

...you may also enjoy:

http://www.gowrikumar.com/c/index.php

http://blog.regehr.org/archives/213

...and learn to use a memory error debugging tool like:

http://elinux.org/Electric_Fence

http://valgrind.org/

...Besides C, other ways of expanding your horizons would be to learn things like: Prolog, Lisp, Haskell, and/or Verilog.

Learn secure coding. I think 80% of secure coding is making sure good coding practice are done, and the rest are spotting algorithm/procedural issues (for example, bad crypto isn't exactly "coding practice", but more of a conceptual fault)

These discussions may be useful:

"How to C (in 2016)": https://news.ycombinator.com/item?id=10864176

"Critique of 'How to C (in 2016)'": https://news.ycombinator.com/item?id=10908217

EDIT: Fixed formatting error

> My objective is to better understand how computers work, how ruby works...

Check out Pat Shaughnessy's Ruby Under a Microscope [0].

It gives a nice overview of the internals of MRI. It doesn't cover a who lot of the C code, but references plenty of it and where it can be found in the source code of MRI. Grab the book, the source for MRI, and do some digging.

[0] https://www.amazon.com/Ruby-Under-Microscope-Illustrated-Int...

I'd recommend Ben Klemens' excellent book "21st Century C - Tips from the New School" [0]. This book teaches you modern C techniques and, most importantly, the tooling that modern C programmers use (git, autotools, valgrind, etc.) It also covers commonly used libraries to help you from reinventing the wheel (GLib, POSIX standard, SQLite, libxml, & cURL.)

As mentioned in another post, David Hanson's "C Interfaces and Implementations - Techniques for Creating Reusable Software" [1] is a great book, stressing the design of good APIs. This book in particular might help you in your goal to become a better engineer.

On the free side, there's an excellent PDF by Jens Gustedt, "Modern C" [2]. I've not read the whole thing but it seems like an in-depth look at C11.

John Regehr's blog "Embedded in Academia" [3] is a good resource for C programming. You'll learn a lot about weird edge cases and undefined behavior. He also has a recent post about teaching C, with suggestions for resources [4].

[0] https://www.amazon.com/21st-Century-Tips-New-School/dp/14919...

[1] https://www.amazon.com/Interfaces-Implementations-Techniques...

[2] http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf

[3] http://blog.regehr.org/

[4] http://blog.regehr.org/archives/1393

Implementing some dynamic data structures should give you a good understanding of how pointers work and allocating and freeing memory. Start with linked lists, then binary trees, then B-trees if you have time. Priority queues (heaps) are fun too.

My recommendation would be to work through Computer Systems: A Programmer's Perspective [0] if you're comfortable with K&R.

David Hanson's C Interfaces and Implementations is also excellent.

[0] http://csapp.cs.cmu.edu/

Really it all comes down to reading and practice. Instead of writing your personal duct tape code in ruby why not try it in C? Sure it will be harder at first but it will make you a better programmer all around. Also reading OS code (like plan9/9front, *bsd, or xv6) will help you learn both how it works, but also how to write better. I don't really do programming problems because they don't give me anything useful at the end other than the knowledge. If I want to practice I'm more inclined to try solving a problem I have in a new way.

Do the Pintos projects. You will learn a bit about operating systems too.

That was certainly the moment in my education where I went from shaky to moderately confident about C.

Pintos is nice because there's an extremely thorough test suite already written before you. It's easy to measure your progress (and know when you are done) by the test report. Like TDD, without the pain of you personally having to write the tests upfront.

https://web.stanford.edu/class/cs140/projects/pintos/pintos_...

In the bad old days, when, from memory and comparison with vast improvements in the later editions of K&R's chapter on pointers etc., the Lions' Commentary on UNIX 6th Edition, with Source Code (https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6t...) was held by many in equal or greater esteem than K&R. The code has bee implemented as xc6 (https://en.wikipedia.org/wiki/Xv6), but I haven't looked at it.

Do online courses form coursera and edx,and try to complete all the assignments..this helps a lot

You may find the linked note on learning how computers work useful. Basically, I think that the value of knowing C in this respect is rather limited and that there are much better ways to do that. Not to say that C is not worth learning, of course, for its own merit. https://news.ycombinator.com/item?id=12118980.

I agree with the recommendation here to read Expert C Programming: Deep C Secrets by Peter Van der Linden.

As for practice: the challenge in learning new tech is always to find a small-scale project that motivates you to build something. As a mostly-Rails developer like you I've found a couple opportunities to write C by building Postgres extensions. Here are my two:

https://github.com/pjungwir/aggs_for_arrays/

https://github.com/pjungwir/inetrange

Both of those are used in production systems and had good justification for dropping down to C.

Or here is a tiny patch to the Postgres btree_gist extension that I am hoping to get merged:

https://commitfest.postgresql.org/10/332/

The JSON support in Postgres is still pretty new. Maybe you could write some worthwhile additions for dealing with json or jsonb data? I would just look at underscore.js for inspiration.

Also if you have a collection of personal shell utilities, you could try rewriting them in C. Here is one of mine:

https://github.com/pjungwir/range

It is for printing a range of numbers like `1, 2, 3`. It is surprising how many features you can add to a tool like that! (It is a bit of a joke, and I have since learned bash gives you `{1..10}`. But something similar could still make a good learning project.)

Perhaps you could also write a ruby gem that wraps some C library. For instance I'm fond of the jsmn JSON parser [1]. Maybe a gem built around that could give performance benefits? Or maybe some way to easily use Protocol Buffers instead of JSON for Rails web requests?

[1] http://zserge.com/jsmn.html

Learn writing code that uses IPC -> multi-threading -> linux OS -> Kernel

Write a chat server capable of handling concurrent clients, and write a front-end client in Ruby.

You'll need a thread-safe FIFO datastructure, such as a queue, handle sockets, define a communications protocol (or borrow one, I'd recommend IRC).

Bonus: This will also teach you more about the Internet protocol suite (https://en.wikipedia.org/wiki/Internet_protocol_suite), particularly the Application/Transport layer.

Side-note: Project Euler and cryptopals problems are not well-suited for C, use the right tool for the job.