You will need quotes for the path.

cd "C:/Path/To/Your/Project"

Remove nul file.

rm nul

Happy days.

The build was crashing with a Ruby error related to missing standard libraries. It turns out Netlify was using Ruby 3.4.x, and some gems that used to be auto-included are no longer there by default.

The fix was simply adding these two lines to the Gemfile:

gem "csv"
gem "logger"

To prevent this from happening again it is possible to pin the version via a .ruby-version.

Now I have moved the “articles” section to two new journals, events and career.

Some journal entries will be long, some will be short. But I think the idea of the site as a whole flows better like this.

In the case of the tutorials, I am leaving them where they are, but removig the link in the navigation bar. I think the core of the site as of today is journals, and it should be the only thing with a link in the nav.

My first conference

It was the first time I attended a conference. I had done one-day trainings previously through my company, but I hadn’t attended a conference until this week.

The “spirit” that is in the air at the conference is amazing. Lots of people who are normally coding for hours alone in front of a computer now are together talking, attending presentations, and eating together.

It is really inspiring and refreshing, I would say. It makes all those deadlines from the last few months feel more meaningful somehow (we clearly belong somewhere!).

Masterclass

I attended a one-day masterclass with Kent Beck called Tidy Together: A Software Design Masterclass.

Something interesting I learned was a graphical way of representing Design vs Features, and understanding how, in order to not end up in the “feature saw”, it is convenient to do a small refactoring before implementing each feature to provide a structure for future work.

I won’t try to describe the full day here. I just can say that sharing a day with Kent as a teacher was a real privilege. I learned and felt very inspired to continue learning.

Talks

I attended many interesting talks. I had to choose specific sessions to attend because there were always three running simultaneously.

I chose many AI-related sessions - I have been working with LLMs in the last few months, so I find the topic interesting. Some notes I took across different sessions:

• Using LLMs for writing code is something now embraced by even the most experienced developers. There is a lot of excitement around how the models keep being improved.
• I have the impression that fully vibe coding a project is something that is, at the moment, only working well when coding alone. The process is about designing the high-level way of building the project and advancing “until you can’t steer it in the right direction anymore”. Once you reach that point, it is necessary to restart the process in a new chat and apply the learnings in this new iteration for the architecture to be more correct from the get-go.
• Techniques and libraries are available for developing agents in different languages. There are many different approaches and people who defend their specific way of designing these systems. I have the impression there is a tendency to make “too many calls to the LLM” to solve a problem that could be solved many times in a more deterministic way. It is not only important for the software to give the desired outputs.
• There are ways of doing AI in a green way. Charles Humble gave a beautiful talk about this.
• I have been working with vector databases, but it was refreshing to see a full introduction to the topic to clear doubts.

I did attend other talks (Crypto, Naming conventions, C4 Model, Sonic Pi, etc.). But AI, I think, was the predominant topic, and also a topic I needed to dive into on this occasion.

Conclusion

I loved the conference. I will definitely come back in the future.

This was a good opportunity to talk AI with people. Even though I’ve used AI to assist in my coding for a while, and even though I’ve already built RAG projects using vector stores and LLMs, I have never written anything in my blog about it - the space changes so rapidly that I didn’t want to think of writing, maybe? I’m not sure. But here it is, finally, some notes about AI in the blog :).

Truth to be told, at the time I am writing this post, I haven’t been coding Revit API Addins for months (I’ve been doing Desktop apps lately), so if something I write doesn’t make sense, please leave a comment and I will review it. Here it goes:

Hot Reload During Development - Rapid Iteration

We all want to modify the code a little bit and immediately jump to the Revit UI and see if it does what we want. But the default setup requires you to close Revit, build the new DLL and open Revit again. It takes time.

For a solution, I would recommend anyone to take a look at Joshua Lumley’s example to achieve rapid iteration (hot reload). I think what is best from his example is that it is pure code (no magic happening in the background), so it opens the door to more learning than when using a pre-built tool for hot reload (e.g. RevitAddInManager).

From what I remember, basically works like this: a single DLL will be “locked” (it might be the one you point to in the addin file). That one you can’t really modify. But that single DLL, using reflection (the “invoke” mentioned by Joshua), can call other DLLs that can be hot-reloaded. Then you end up with at least two projects in your solution: one has the code that will be locked, and the other one/ones will contain code that is called using reflection and hot-reloaded at will.

How to use Revit Lookup

Revit Lookup is clearly the must-have tool for developing Revit Addins, but when starting to code for the first time, it doesn’t seem very intuitive. I am going to write a few bullet points below, hoping it will be useful for someone:

• The only command I’ve always used is the “Snoop Selection”. Other parts of the tool might be very useful, but if you only learn to use “Snoop Selection”, it is already a lot of help.
• In this previous post I explain how I use “Snoop Selection” to learn how to set a parameter of a Revit element - Have a look at it, hopefully it makes sense.
• When you open an element with “Snoop Selection”, what you are doing is discovering whatever that element resembles in the Revit API. You are having a look at an object of a Revit API class; therefore, you should be opening the Revit API docs page and taking a look at the class itself as well.
• When you look at the element in Revit Lookup and compare what you see with the class in the API docs, you will see that some information is missing. That’s normal - you will only see in Revit Lookup what can be shown without providing further arguments (see explanation here).
• Sometimes the UI element you click and the class that pops up will not make sense straight away, and that’s normal. I think it is normal to “imagine” how the classes are in the Revit API from only looking at the element in the Revit UI - then, when we open the corresponding class and dig into the docs, sometimes we learn things are very different from what we imagined.
• At the end of the day, when using Revit Lookup, you are, in a way, diving into the Revit API docs. For understanding the Revit API docs, I think “Object Oriented Programming” is something useful to study - Google it, watch a video, or maybe have a look at this book.

Go with Windows Forms

I have worked with Revit Addins using WPF. As per this comment, I would recommend anyone to use Windows Forms instead.

Understanding Transform

I would look at this video (Joshua again) if I need to understand Transform (it is the only animation I’ve found online showing it work).

Conclusion

That’s it for today. I might put together more relevant notes in the future and create another post. If this was useful for you, and you would like something specific to be added in the next post, please don’t hesitate to message or leave a comment.

That forum post reminded me of a Douglas Crockford presentation I watched a while ago (maybe this one - I didn’t save the link to the exact video) on the “good parts” of JavaScript (there is also a book). The main idea that stuck in my head after the presentation is that not all the features in a language are necessarily there to be used - some are there because they can’t be taken out (it’s too late). So we need to learn to use the good parts only.

Maybe there is a list of methods of the Revit API that is best not to use. If someone has a link to an article listing them please let me know.

It was my first time writing code in Pascal Script, and my first time working with Inno Setup. It was a fun experience and I learned a few new things.

Today I wanted to write down some of my learnings to have them as a reference for the future, and to share them in case anyone trying to update an installer script for the first time could find them useful.

Documentation

The Inno Setup documentation is available online and also in the Inno Setup app by going to Help > Inno Setup Documentation (or pressing F1). For some reason, it was easier for me to find things in the Desktop app.

It is worth mentioning that sometimes the docs refer to files in the installation folder (the “Examples” subfolder or the ““ISPPBuiltins.iss” file), so you have to find your installation folder (mine was at %localappdata%\Programs\Inno Setup 6) or use as a reference the online repository (I leave links to the “Examples” dir and “ISPPBuiltins.iss” file).

Comment: if you want to save the link to a specific section of the online documentation, right-click the link on the web page and choose “Copy Link” - otherwise when using left clicks, the URL remains the same.

ISPP and Pascal Script

When working with the .iss I had to work with Pascal Script code and Preprocessor code.

For me, Pascal Script is easier to write, but the Preprocessor code has the advantage of allowing you to do compile-time tasks. The truth is that the online community around Inno Setup is very strong, and most of the common problems have already been solved and their solutions are available online.

Global Settings

The [Setup] section contains global settings - here is where I used preprocessor code the most.

I think that maybe this is one of the places where the power of Inno Setup shows. There are a lot of different directives and by setting them a lot can be achieved without much code.

Constants

It is important to understand how to access these constants using ExpandConstant.

The constant that called my attention the most was {tmp} because it is not the value of the user’s TEMP environment variable, so it can be confusing.

Command line options

The command line parameters are listed here.

If using /SUPPRESSMSGBOXES parameter, you need to use the suppressible msg boxes.

When using /LOG parameter you get more information than the entries you log manually with the Log function, which is cool.

Notes on Pascal Script

I’ll be brief because I don’t want to replicate the docs here.

I got stuck a few times because of using = instead of := to assign a variable. This got specially confusing when jumping between setting the global settings at [Setup] section and after working with Pascal Script in other sections.

I think I would most of the time add a BoolToStr function as per here to work more comfortably.

Conclusion

Inno Setup is an amazing tool. At first glance, I didn’t feel very excited about coding in Pascal Script, but when I realized how good the tool is and how strong the online community around it is, I realized I’m very lucky I got to work with it. I would recommend it to anyone thinking of creating a Windows installer.

After testing with a few solids I arrived to the conclusion that the Edges in the EdgeArray are in the correct order (two consecutive Edges share a point) but they sometimes don’t have the same orientation.

In a closed CurveLoop, every Curve starts where the previous one ended. Instead in an EdgeArray, every Edge shares a point with the previous Edge, though you don’t know for sure which point. Because of that, when making the EdgeArray into a CurveLoop it is necessary to check the orientation of each Edge and correct it if necessary.

Last comments:

• I used the AsCurve method from the Edge objects to get the curves, and there is where I identified the different orientations.
• There is a GetEdgesAsCurveLoops method available in the Face class, which might be useful to avoid coding the EdgeArray to CurveLoop, but I haven’t tried it out.

Script for opening everything:

#!/bin/bash

API_DIR="/path/to/api/project/dir"
SITE_DIR="/path/to/site/project/dir"

# opening the API in vscode and running the the API in a new terminal 
code "$API_DIR"
gnome-terminal --working-directory="$API_DIR" -- bash -c "
    source '$API_DIR/.venv/bin/activate';
    python '$API_DIR/main.py';
    exec bash
"

# opening the Site in vscode,running the Site in a new terminal, and opening it in firefox
code "$SITE_DIR"
gnome-terminal --working-directory="$SITE_DIR" -- bash -c "
    docker start containername -i;
    exec bash
"
sleep 5 # waiting for 5 seconds untill the site is running
firefox http://0.0.0.0:8080/

Script for closing it all:

#!/bin/bash

# Close all VS Code instances
pkill -f "code"

# Close all terminal windows
pkill -f "gnome-terminal"

As many other scripts, I saved these two in my code snippets repository.

Implementing some of the hotkeys required preventing the default browser behaviour (event.preventDefault()). As of this point I use together the site hotkeys plus a browser extension to navigate and play around on the site without the mouse.

Jekyll Minima Comments

Some hotkeys work on every page (for scrolling and navigating to the search page). Those I added in a <script> tag in _layouts/default.html. Others work only in a post (for navigating to the next or previous post). Those I added in a <script> tag in _layouts/post.html.