Code:

• next_working_day.clj
• next_working_day_2.clj

Notes

• Injee
  • https://tossconf26.kaniyam.com/
  • Tamil Linux
    • Telegram
      • https://t.me/tamillinux
    • ilugc
      • https://ilugc.in/
• https://libl.in
  • https://clojure-book.gitlab.io/book.html#_installing_stuff
    • https://yu7.in/clj-installing-stuff
      • Now it’s fixed :D
• Clojure Book
  • Proof read with A.I
    • https://gitlab.com/clojure-book/clojure-book.gitlab.io/-/tree/proof_read
  • Release in all human languages
• -ve’s
  • Video series about ring is stalled
  • Stats with Clojure book is stalled
    • https://scicloj.github.io/stats_with_clojure/

$ lein ring uberjar

This will create a standalone JAR file in the target directory. Let’s renameit to my-app.jar for convenience.

Here’s how to host your Clojure Ring app on an Ubuntu VPS:

1. Install Java

sudo apt update
sudo apt install openjdk-25-jre-headless
java -version  # verify

2. Upload the JAR

From your local machine:

scp my-app.jar user@your-vps-ip:/home/user/

3. Run it manually first (sanity check)

java -jar my-app.jar

Your app likely starts on port 3000 by default. You can override it:

PORT=8080 java -jar my-app.jar

You can use browser to test your app at http://your-vps-ip:3000, or http://your-vps-ip:8080 if you set a custom port.

4. Set up a systemd service (so it runs forever)

Create a service file:

sudo nano /etc/systemd/system/my-app.service

Paste this:

[Unit]
Description=My Clojure Ring App
After=network.target

[Service]
User=user
WorkingDirectory=/home/user
ExecStart=/usr/bin/java -jar /home/user/my-app.jar
Restart=always
RestartSec=5
Environment=PORT=3000

[Install]
WantedBy=multi-user.target

Enable and start it:

sudo systemctl daemon-reload
sudo systemctl enable my-app
sudo systemctl start my-app
sudo systemctl status my-app

5. Set up Nginx as a reverse proxy

sudo apt install -y nginx

Create a config:

sudo nano /etc/nginx/sites-available/my-app

server {
    listen 80;
    server_name your-domain.com;  # or your VPS IP

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Enable it:

sudo ln -s /etc/nginx/sites-available/my-app /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

6. Open the firewall

sudo ufw allow 'Nginx Full'
sudo ufw allow OpenSSH
sudo ufw enable

7. Add HTTPS with Let’s Encrypt (optional but recommended)

sudo snap install --classic certbot # install certbot
sudo ln -s /snap/bin/certbot /usr/local/bin/certbot # Prepare the Certbot command 
sudo certbot --nginx # follow the prompts to set up HTTPS

Certbot will auto-edit your Nginx config and set up auto-renewal.

Useful commands after deployment:

sudo systemctl restart my-app       # restart after uploading new jar
sudo journalctl -u my-app -f        # tail logs
sudo systemctl status my-app        # check status

When you deploy a new version, just scp the new jar over and sudo systemctl restart my-app.

Notes

• clj.rs could be a big thing
  • Clofer collapsed:: true
    • Why it started
      • file -> jar -> output
        • Lot’s of files
          • GNU Parallel
          • GraalVM
            • NOOOOOOOOO
            • Oracle
    • clojurers
    • I don’t know a lot collapsed:: true
      • Kanipaan
    • Reddit comment
  • clj.rs
    • Gives me breathing space
    • https://clj.rs
    • Casey Marshall
      • 
      • 
    • Freedom from Java / Oracle
    • Actively Maintained!!
      • Will Clojure community will ensure active maintenance?
    • Jank
      • Clojure on C++
      • LLVM
      • Pointers
    • The Garbage collection
      • In Ruby it was a big topic
    • Fast
    • Huge set of libraries
    • GPU!
      • Rust GPU
    • No more JavaScript?
      • I hate JavaScript
    • Embedded Systems
    • OS programming
    • Data Science
    • Clojure on Zed editor?
      • Jpyter Lab
      • VSCode is slow
        • Take up resources
      • M$ - common who really trusts them?
    • Less nightmare for Rust dev’s
      • Imagine the productivity gain!!!!
    • Please rally behind this project
    • No more Clofer, grow, and long live https://clj.rs/
    • -ve’s
      • Claude is used
        • A closed model
      • Only 1 person project
      • Maybe the world does not know
      • Underwhelming reaction
    • What I will do
      • Try to write some Clojure programs with clojurust
      • 
        • Learn Rust, make it learnable.
      • Watch https://clj.rs , report about it
        • Contribute to it if I can (it’s a big if)
      • Update my Clojure Book
        • 
      • Write a Lisp compiler in Rust, just for Hobby
      • Contribute to Stats With Clojure
        • 
  • Clojure should keep moving collapsed:: true
    • Rust is a great idea now
    • Who knows what next?
    • Clojure foundation
      • Official Clojure implementation on various runtimes
      • Standard Clojure API
      • Target many platforms
        • Migrate / compile to many platforms

Notes

VSCode settings.json

"calva.outputDestinations": {
  "evalResults": "repl-window",
  "evalOutput": "repl-window"
}

• Code

Notes

• Code
• https://injee.codeberg.page
• curl -I http://localhost:4125/files/something
• curl -X GET http://localhost:4125/ops/files | jq
  • https://jqlang.org/
• h<ttps://tika.apache.org/>
• https://mvnrepository.com/artifact/org.apache.tika/tika-core/3.3.0
• Tika in Action
  • 
  • https://www.amazon.com/dp/1935182854
• Chicken Tika
  • 
  • Chicken Tiken Masala
    • 

Hello Clojurians,

I’m happy to announce that the Clojure book has gotten a bit better! A few days ago, I received an email from someone named Alex Bedner. He read my Clojure book from start to finish and was kind enough to share some corrections. I’ve implemented them, and you can find the updated book here: https://clojure-book.gitlab.io/

I did try to upload the print copy to Amazon, but for some reason they require additional verification from my side — and I’m not entirely sure what that entails. I’m not great with bureaucracy, so getting the Amazon listing sorted will take some time. In the meantime, Alex Bedner’s proofread version of the Clojure book is available at the link above. I’m deeply grateful to him.

There’s still a lot to do, and I remain committed to Clojure. Here are the things I’d like to finish in the book:

Creating Your Own Libraries (https://clojure-book.gitlab.io/book.html#_creating_your_own_libraries) — this section currently has no accompanying video. I’ve been meaning to make one, but haven’t gotten around to it yet — I can’t quite explain why.

Debugging with Calva (https://clojure-book.gitlab.io/book.html#_debugging_with_calva) — I need to write this section, with plenty of screenshots so readers know how to debug with Calva. At the very least, I’d like to link to the Calva website, where the creator has put together some excellent videos.

I’d also like to add a section on Paredit at some point — we’ll see how that goes.

Finally, I’d love to use LLMs to help proofread and polish the book further. English isn’t my first language, and I’ve found that AI tools have been genuinely helpful in improving the quality of my writing lately.

Once again, thank you to everyone who has said kind words about the book, pointed out corrections, offered criticism, or praised it. All of it is valuable input, and I’ll make the most of every bit of it.

Notes

• CSS
• CSS in Hiccup
• CSS with garden

Cookie

• Stored on the client (browser)
• Data is sent with every HTTP request in the request header
• Can persist for a set expiration time (even after the browser closes)
• Limited to about 4KB of data
• Can be read by JavaScript (unless HttpOnly flag is set)
• Examples: remembering a user’s theme preference, tracking analytics

Session

• Stored on the server
• The browser only holds a small session ID (usually in a cookie)
• Typically expires when the browser is closed (or after a server-defined timeout)
• Can hold much larger amounts of data
• More secure since the actual data never leaves the server
• Examples: storing login state, shopping cart contents

How they work together

Browser                          Server
  |                                |
  |--- Request (with session ID) ->|
  |                                |--- Looks up session ID in store
  |                                |--- Retrieves session data
  |<-- Response -------------------|

A common pattern is: the server creates a session, stores the session ID in a cookie, and on each request the browser sends that cookie so the server can find the right session data.

Quick comparison

Rule of thumb: Use cookies for small, non-sensitive data you’re okay storing client-side. Use sessions for sensitive data or anything that shouldn’t be exposed to the client.

Notes

• Code