A piece of glass, some bits of tinfoil, a sheet of plastic, a couple of razor blades, and a few assorted bits and bobs are all it takes to build this TEA nitrogen laser. Oh, and a 5,000-volt flyback supply with enough amperage to stop your heart. You’ll need that too.

Seriously, if you choose to follow [MultiverseCurator] ‘s example and build this laser, you’ll want to take the proper precautions. A transversely excited atmospheric laser is simple in concept, but there are plenty of ways for them to go wrong. Unlike the gas lasers used in laser cutters, there’s no enclosed resonator cavity or mirrors. Rather, the excitation takes place across a narrow gap between two electrodes, using atmospheric nitrogen as the lasing medium. This results in hard UV emissions, which means you can’t see them with the naked eye. Add to that the spark gap creating extremely loud discharges as the laser operates, and hazards abound. Proceed with caution.

Construction starts with a flat glass plate and a pair of large capacitors made from aluminum foil plates separated by a plastic dielectric. The razor blades are connected across the capacitors, separated by a narrow gap, with an inductor made from magnet wire in parallel. A spark gap made from nuts and bolts goes in series, and the whole assembly gets connected to a high-voltage power supply — [Multiverse] used a ZVS driver and a CRT flyback transformer with an eight-megohm resistor in series. The video below has all the build details.

It’ll take a little fiddling to get it lasing, and you’ll need something phosphorescent to see the UV light — a scrap of copy paper should do. But the results are pretty amazing for something made from scrap. If you want to take the design to the next level, you’ll want to check out [Les Wright]’s TEA laser build.

youtube.com/embed/uLyVpYIYT1E?…

hackaday.com/2025/03/13/got-ju…

You can argue if bash is a good programming language or not, but you can’t argue that it is a programming language. However, there are a few oddities about it that make it different from most other languages you probably know. For one thing, variables are dynamically scoped. Second, you can easily change variables in an upper scope. This leads to a problem when you want to do something like reset your path:
#!/bin/bash
#: This does NOT work
PATH=/usr/bin:/bin

Well, actually, it does work; it just doesn’t work the way you imagine it might. The key is to realize that when you execute our script (say, resetpath), a new copy of bash runs. It inherits all the variables from your shell. Now the script sets PATH for the new copy of bash. Anything else you run in that script will see your change. But when the script exits, the new copy of bash is gone and the old copy sees the same old PATH it always did.

Sometimes, this is a benefit, similar to “call by value” in other languages. However, what if you want to influence things? What’s more is that the situation is just the opposite within bash functions. For example:
#!/bin/bash

b() {
echo B: $x
x=200
}

a() {
x=100
b
echo A: $x
}

a
#: output
#: B: 100
#: A: 200

Function b has no difficulty reading and even setting variable x.

The Answer, Of Source Course

The answer to the first problem is to use the source command (which can be either the word source or a single period). This tells bash to avoid running a new interpreter and just pretend you’d entered all the lines in a file from the console.

This is great sometimes. Our resetpath script will actually work just fine with either of these commands:
source resetpath
. resetpath

You don’t even need the #! line, although it doesn’t hurt. However, there are a few problems.

The Catches

First, if you exit, then you exit the entire shell, not something you probably meant to do. Second, you wind up polluting the variable space of the parent. For example, if your script creates a function X, with a regular shell script, that function goes away as soon as your script stops. With a source script, function X now will live forever unless you do something about it.

Neither of these problems are insurmountable, of course, and you’ll see a few ways to address it in the example code in this post.

A Simple Example

If you spend a lot of time on the command line, you might want to have shortcut names for directories. What’s more, you might want to execute a little script when you go to particular directories or even when you leave them.

My plan is to keep a simple file in ~/.proj_dirs. To keep things simple, I’m assuming you can figure out the bash format:
PROJ_DIRS["docs"]="~/library/documents"
PROJ_DIRS["video"]="~/library/videos"
PROJ_DIRS["arduino"]="/home/alw/projects/embedded/Arduino"
. . .
The eventual goal is to replace the cd command (or, at least, allow for that). However, it would be a pain to have to write something like “source pcd arduino” every time.

The Alias Solution

The answer is pretty simple. You can create a script that can install itself as an alias. Here’s the basic flow:
#!/bin/bash
#: This is not a bash shell script
#: But needs to be sourced. However...
#: Try:
#: eval $(__project_dir.sh --__install project_dir)
if [ "$1" == "--__install" ] # this should only be called from "real" script
then
aname="$2"
if [ "$aname" == "" ]
then
aname="pcd"
fi
echo -n "alias '$aname'='source "
aname=$(realpath -s "$0")
echo "$aname'"
exit 0
fi
#: Your source script goes here
...

The idea is that if you run as a regular script with –__install, it returns the alias command. You can then eval that in, for example, a startup script (like .bashrc or .profile), and then you’ll have the alias you want. By default, the code uses pcd, although you can set up any name you like on the command line. You could even create an alias for cd if you wanted to do that.

Why Not Automatic?

You could, of course, detect if you were running normally or as a source automatically. Turns out this is somewhat finicky across shells, although if you are sure you are always using real bash, it is feasible. For example:
if [[ "${BASH_SOURCE[0]}" == "$0" ]]
then
echo I am not sourced!
fi

Variables

Once you have the basic framework, it is easy to write the scripts to read the “database” (also using source) and do the actual work. However, there is a slight problem. Once you produce all the variables you need to do the work, it leaves all that pollution in your shell’s namespace.

Of course, you could write a function to clean up everything you use, but that’s a pain and error prone, too. A better idea is to write your code in a bash function. Then you can use local variables that will go away when the function returns. That leaves you with just your function to clear up with unset.

That leads to this simple framework:
#!/bin/bash
if [[ "${BASH_SOURCE[0]}" == "$0" ]]
then
if [ "$1" == "--__install" ] # this should only be called from "real" script
then
aname="$2"
if [ "$aname" == "" ]
then
aname="pcd" # default alias name
fi
echo -n "alias '$aname'='source "
aname=$(realpath -s "$0")
echo "$aname'"
exit 0
fi
echo "You must source this script"
exit 1
fi

#: Ok your script goes here

main() {
. . .

}

#: Be sure to have this at the end
#: Actually named with underscores in the real code
#: But that upsets the rendering in browser
#: Actual code at gist.github.com/wd5gnr/c5681f2…
go() {
local tmprv
main "$@"
tmprv=$?
unset main, go
return $tmprv
}

go "$@"
return $?
The very bottom calls the go function, which calls your main function. Then the go function destroys your main function and itself. If you create new functions that you don’t want to keep around, you’ll need to destroy them yourself. Besides, you might be creating functions you want to keep, so the framework can’t decide.

The Whole Thing

You can find the entire example on GitHub. Outside of the management of the alias and the variable scope, the script is unremarkable. Note the optional scripts in the directories (.dir_enter and .dir_exit) are sourced also, so they only need to be readable (-r) not executable (-x).

The only other nuance is that if you enter anything as a directory that the program doesn’t recognize, it assumes it is an actual directory, so you can use this to replace the cd command entirely if you want.

Since the script can tell if it is sourced or not, it is possible to start in the source mode and then call yourself as a normal script to do work where that makes more sense. As usual with bash, there are lots of possibilities.

We talk about bash programming a lot around here. Debugging can be helpful, although they haven’t packaged the debugger for newer versions of bash lately.

hackaday.com/2025/03/13/linux-…

A cosa serve il Comitato dei Genitori?

Al fine di definire con la massima correttezza le funzioni del comitato, riportiamo uno stralcio del primo articolo del Regolamento del Comitato.

Il Comitato si propone i seguenti obiettivi:

1) Facilitare la convocazione dell'assemblea dei genitori.
2) Promuovere la partecipazione democratica dei genitori negli organi deputati.
3) Favorire la comunicazione fra le varie componenti della scuola all'insegna della più totale trasparenza.
4) Contribuire all'individuazione e all'analisi delle criticità - materiali e non - che dovessero emergere. nell'ambito scolastico, al loro monitoraggio, e alla formulazione di proposte di risoluzione percorribili
5) Vigilare sul rispetto dei diritti di genitori e studenti all’interno della scuola.
6) Favorire la conoscenza del Patto Educativo di Corresponsabilità e del Piano dell’Offerta Formativa redatti dall’Istituto presso genitori e studenti coinvolgendoli nel monitoraggio dell’efficacia e dell'attualità educativa.

Il Comitato si impegna nell'adempimento degli obiettivi prefissati attraverso le seguenti modalità operative:

1) La convocazione dell'"Assemblea dei genitori".
2) La redazione di comunicati pubblici o l'invio di comunicazioni mirate ai soggetti coinvolti nella gestione dell'Istituto.
3) La redazione di richieste di accesso a dati e documenti amministrativi, secondo le modalità previste dalla normativa.
4) L'organizzazione di gruppi di lavoro o la partecipazione a gruppi di lavoro istituiti da altre realtà, in merito alle tematiche di interesse per l'Istituto.
5) La promozione di incontri di formazione per genitori, aperti a docenti e studenti.
6) Il confronto e la collaborazione con i Comitati Genitori e Consigli di Istituto delle altre scuole. superiori della città, al fine di realizzare scambi di informazioni e di esperienze e di intraprendere eventuali iniziative comuni in collaborazione.
7) L'allestimento e la messa a disposizione di raccolte di documentazione di supporto per le famiglie o di rendiconto delle proprie attività.
8) La promozione e l'organizzazione di incontri formativi o di eventi ricreativi.
9) La formulazione di proposte e pareri (ex art. 3 c. 3 del DPR 275/99 c.d. Regolamento dell'Autonomia Scolastica) al Collegio Docenti e al Consiglio di Istituto ai fini della messa a punto del POF e dei progetti di sperimentazione.
10) La promozione di interventi di manutenzione dell'edificio scolastico

I genitori non rappresentanti possono partecipare alle attività del Comitato?

Anche i genitori non rappresentanti possono partecipare ai Gruppi di Lavoro costituiti dal Comitato.
I Gruppi di Lavoro attualmente operativi sono i seguenti:

1) Gruppo Comunicazione

Finalità: comunicazione pubblica delle attività del Comitato verso i genitori e verso la scuola, individuazione dei canali di comunicazione più appropriati, gestione strumenti digitali di comunicazione e archiviazione.

2) Gruppo Trasparenza.

Finalità: creare uno strumento per armonizzare l'attuale conoscenza da parte della componente genitori, delle norme scolastiche, delle delibere, dei regolamenti di funzionamento dell'Istituto scolastico

3) Gruppo Formazione.

Finalità: elaborazione di contenuti ed incontri formativi in merito alle tematiche di interesse generale per creare e performare uno strumento utile al coinvolgimento dei genitori come componente scolastica e supportare i rappresentanti delle classi nella comunicazione e nella formazione (anche) normativa.

Cos'è il Comitato dei Genitori?

Il Comitato dei Genitori è un'associazione prevista da sensi del Testo Unico delle disposizioni legislative in materia di istruzione (art. 15 comma 2 del D.L.vo 297/94). Possono essere membri dell'associazione solo i rappresentanti di classe eletti durante ciascun anno e i rappresentanti dei genitori eletti del Consiglio di Istituto.

Il Comitato dei Genitori può svolgere una funzione fondamentale per valorizzare il ruolo di tutti genitori e per rafforzare la loro partecipazione diretta e indiretta negli organismi scolastici.
I genitori infatti devono maturare la consapevolezza che i membri del Comitato, in quanto rappresentanti di classe, sono di fatto eletti dai genitori delle singole classi in occasione del primo consiglio di classe dell'anno.
Il Comitato dei Genitori, di cui fanno parte anche i quattro genitori eletti come rappresentanti in Consiglio di Istituto, è anche un formidabile strumento di connessione tra essi e tutti gli altri genitori.

Infine, il Comitato dei Genitori possiede un'ultima prerogativa formale molto importante per la partecipazione di tutti i genitori, ossia la possibilità di convocare più facilmente l'Assemblea dei Genitori. Solo se esiste un Comitato dei Genitori è infatti possibile convocare l'assemblea su richiesta della metà dei rappresentanti eletti, invece che con la raccolta di 300 firme. L'assemblea plenaria di tutti i genitori della scuola costituisce l'unica occasione prevista dalla normativa per discutere collettivamente le istanze presentate dai genitori.