Forem: Si Dunn

Hello, Rust. This is C. Play Nice!

Si Dunn — Wed, 15 Feb 2023 01:20:47 +0000

How to compile and run a 'Hello World' C script using a Rust build file with the cc crate.

In a previous post here on Dev, I grumbled about being impatient while learning Rust. And, after floundering miserably at Rust procedural macros, I promised to go back to the Rust Playground and get more experience.

On my way back there, however, I stopped off long enough to look through some of The Cargo Book and found a simple way to compile and display a "Hello, World" C file by adding it to a Rust build script.

Check out the "Build a Native Library" section of The Cargo Book and look at its examples. I chose to focus on the Rust build script using a build-dependencies entry from Crates.io. cc-rs is "[a] library to compile C/C++/assembly into a Rust library/application."

In The Cargo Book, find the text that begins: "Not to fear, though, this is where a build-dependencies entry would help!"

Enter and save the simple code examples that are shown. And be sure to place each file in the correct subdirectory. For example, the build.rs file should not be placed into the src folder. Put it in the folder with the Cargo.toml file. Meanwhile, be sure the hello.c file is placed in the src folder, along with the main.rs file.

I chose to add two more "message" lines to the printf(); portion of the boring hello.c file. This C file is compiled and displays text on the screen right after you enter cargo build at the prompt and then cargo run. Here is my hello.c example:

// hello.c - Simple C program to display "Hello World"  
// Header file for input output functions
#include <stdio.h>
// main function - where program execution begins
void hello(){
// prints hello world
printf("Hello, Rust World! This is a message from C World!\n");
printf("And another message to Rust World from C World!\n");
printf("But now, that's all, folks!\n");
}

C:\Users\sidun\Documents\Rust_code\projects\hello-world-from-c>cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `target\debug\hello-world-from-c.exe`
Hello, Rust World! This is a message from C World!
And another message to Rust World from C World!
But now, that's all, folks!

After getting ahead of my Rust-beginner skills and floundering at procedural macros, it has been nice little confidence boost to see that I can get some Rust and C to work together. If you are a Rust beginner, be sure to spend some quality study time with The Cargo Book, as well as The Rust Programming Language book.

Cover image credit: Photo by Si Dunn

Macro-Roni? AI-yi-yi!

Si Dunn — Wed, 08 Feb 2023 21:16:11 +0000

Old Tutorials, ChatGPT, and No Mentor: How I Failed to Build a Rust Procedural Macro That Worked. (Until One Finally Did.)

Have you heard the old saying "Never get ahead of your skis"? Or your skates? Or your common sense?

Recently, I got tired of being a post-"Hello, world" Rust newbie, especially one who has been plodding forward at a turtle-like, spare-time pace. I've been trying to become competent at Rust by using books, online tutorials, and no in-person guidance, one code example at a time.

Rust is not an easy language to learn, especially that way. And, unfortunately, I still work remotely and must--for survival's sake--minimize my exposure to a wide range of illnesses. That sums up my basic path forward.

In a burst of impatience, however, I decided to vault ahead and tackle something more substantial than, say, shadowing or immutability, in (another old saying) one fell swoop. After all, I had successfully done some remote work not long ago that required a few basic Rust skills. Whatever I jumped into next involving Rust, I could figure out on the fly, I reasoned. Nope!

Out of the digital blue, and without fully comprehending what the term meant, I decided I would teach myself how to create a Rust procedural macro. Easy, peasy, I reasoned. What could be hard about making some macro-roni?

Speaking of fell swoops and getting ahead of one's skis, let's note my photograph (above) of the failing, falling pole vaulter and move on to some other sports imagery. When I swooped off the end of Rust's macro ski jump on my first attempt and briefly stood on thin air like the cartoon character Wile E. Coyote...I realized I had left both skis behind, neatly parked at the top of the run. The hard landing that followed completely broke my common sense. Indeed, I ran back up the macro mountain to try again.

I re-consulted a Rust how-to book for more information. The book described the alleged wonders of procedural macros but gave no complete code examples. I found some aging procedural macro tutorials online and carefully copied their code. Cargo test? Fail. Cargo build? Fail. Some of them tried to compile, then flashed some error messages. Cargo run? Exactly none.

Over the next two days, I tried to run and rework the code from several tutorial examples. Always, there were frustrating holes in the how-to descriptions. And clear assumptions had been made that those attempting the tutorials would be smarter and more experienced at Rust than I was. My code "fixes" only made matters worse.

Finally, completely flummoxed by failing to compile even a "Hello, world" procedural macro, I decided to cheat and get help from AI. I asked ChatGPT to show me the code and describe all steps necessary to build a simple, working example.

It took a few minutes to get a response from the wildly popular, overloaded site. But I eagerly copied the arriving code and followed each calm, confident step in the AI-generated tutorial. The secrets of procedural macros were about to be revealed at last, I believed.

Cargo build? Nope. Fail. And this time, I spotted a startling code typo. The "all knowing" AI had told me to use proc-macro in a place where proc_macro clearly was correct. Fixing that, of course, still did nothing to solve my dilemma. Cryptic new error messages appeared.

Defeated at last, I deleted the entire procedural macro saga from my hard drive and vowed to quit Rust. Perhaps I could go home to Python, I reasoned. Or take up C# again and maybe build some model airplanes on the side.

Breaking news! After completely giving up Rust forever for a few hours, I came back for one more round of macro boxing. This time, I ducked and weaved--and noodled around on the web a bit more. And I came across something I should have paid much closer attention to many days ago: The Rust Programming Language book. Very close to the end of its huge piles of pages, it offers some procedural macro examples.

I chose "How to Write a Custom derive Macro." And once again, I ran into descriptions that seemed short on a few essential details. I kept doing the code as shown, and Cargo build kept failing. Finally, almost by accident, I clicked on a screen prompt I had not noticed before: The hidden-lines link in Listing 19-33. The hidden lines now popped into view, and I quickly saw where and why my coding was going off the rails. Copy, paste, Cargo build, Cargo run...for the win!

What's the moral of this story? For me, it's this: I need to reach out more often from my pandemic-walled-off, remote-work castle and humbly ask for help from people who don't mind showing a newbie how to do something that's over his or her head. Trying to learn Rust in a vacuum is a sure-fire way to quickly run out of air. Other newbies should remember this, too, I believe.

Also, I need to go straight back to the Rust playground, stay in line, keep learning patiently, and get much better at the basics first. I've been to the procedural macro mountaintop, yes, and discovered I was almost completely clueless about what I could do once that I was there.

When I do return, please do me one small favor in honor of the procedural macro that I finally got to work. Don't call me "Pancakes."

Cover image credit: Photo by Si Dunn

Rust(y) Cargo!

Si Dunn — Thu, 19 Jan 2023 21:24:01 +0000

Installing Rust & Cargo on a Windows 10 PC

The Rust website offers easy ways to install Rust and its build tool and package manager, Cargo, for several different operating systems.

However, if you use a Windows 10 PC, the simplest path is to just click on the Rust site's "Install" link and choose rustup as recommended. Depending on whether you are using a 32-bit or 64-bit Windows PC, click on the appropriate link to download the rustup-init.exe file. (Note: There is also a Rust download link for those who use a Windows subsystem for Linux.)

Pay close attention to the "Notes about Rust installation" section of the "Install Rust" page. Rust will try to configure the PATH environment variable during installation. But you may need to reboot your computer, or edit the PATH, or even reinstall Rust if there is a problem.

Once installation is complete, go to a command prompt and enter the following commands in any order:

rustc --version

rustdoc --version

cargo --version

You should get responses similar to these:

c:\>rustc --version
rustc 1.66.1 (90743e729 2023-01-10)
c:\>rustdoc --version
rustdoc 1.66.1 (90743e729 2023-01-10)
c:\>cargo --version
cargo 1.66.1 (ad779e08b 2023-01-10)

Rust is working, so now take some time to look at The Cargo Book. According to that publication:

"Cargo is the Rust package manager. Cargo downloads your Rust package's dependencies, compiles your packages, makes distributable packages, and uploads them to crates.io, the Rust community’s package registry. You can contribute to this book on GitHub."

If you happen to have an older version of Rust already installed on your Windows PC, just run the command rustup update to get the most-recent release. After Rust is updated, test the installation using the --version commands listed above.

Thanks for reading. Feedback welcome. (And yes, this is my first big try at writing something with Markdown, so I do have more to learn).

Learning from Out-of-date Online Tutorials & Courses?

Si Dunn — Sat, 07 Jan 2023 18:39:57 +0000

To keep expanding my software knowledge and coding skills, I search frequently for online tutorials and courses. But many that I find are in need of software updates and clearly are being neglected by the authors and/or companies that posted them. It's not helpful to me when I find an online project that looks intriguing yet requires considerably earlier versions of the software I have loaded and am now trying to learn.

I'm guessing the tutorial or course authors did not get paid much, if anything, for their efforts or got very little feedback from those who used the materials. And now they have moved on to other opportunities and challenges in their software careers and have simply left their once-helpful materials marooned in cyberspace.

What can be done about this, realistically? Try to contact the authors and ask them to update what they posted (or at least give you some guidance)? Attempt the tutorial project using the much-newer software releases and force yourself to try to debug and rewrite your way to completion? Use the bones of an outdated tutorial and try to create a new and somewhat different project? Or--???

What approach(es) do you favor?

Hello, World(s)!

Si Dunn — Fri, 06 Jan 2023 16:43:01 +0000

Indeed, hello, multiple worlds! (As I mentioned in one of my posts on the Welcome thread, I have now moved past "Hello, World!" in several programming languages.)

At age 78, soon to turn 79, I don't consider myself much of a software "developer." I'm more of a software hobbyist. Anyway, who's hiring developers born during World War II?

I retired from software technical writing 14 years ago after working for several large telecommunications companies. I used to write hardware and software manuals and training courses and even tested some hardware and software. But that was long ago, in a younger universe...far, far away behind me.

Over the past few years, however, I have been using software "development"--at the hobbyist level--as a way to help keep my aging brain alert, alive, and open to learning. In my own mind, at least, that daily tinkering seems to be working.

I'm now in the process of learning how to get better at working with several software languages and frameworks. I also occasionally write online reviews of beginner-level software books. One other part of my learning process is to find relatively easy software projects, try them out, and attempt to make minor modifications that work (or blow up). I jump from one thing to another as my interests change, so skill-wise I tend to remain just a few steps above "Hello, World!" while I keep collecting more languages and packages to play with. Yes, I know. Definitely NOT the best way to develop any depth in my abilities.

I'm trying to change some of that now, if only to pare down the number of "how to" binders and books currently stacked on my shelves. In short, I'm narrowing my focus a bit. For the near future, I intend to just center my attention on...Java, JavaScript, Rust, Python, C#, .Net, Angular, PostgreSQL, Go, Spring Boot, Haskell, and one or two others I can't seem to remember at the moment.

Anyway, as Buzz Lightyear never said: "To infinite loops...and beyond!"

(Cover photo by Si Dunn)