Danish: You look like you're going to spend your life having one epiphany after another, always thinking you've finally figured out what's holding you back, and how you can finally be productive and creative and turn your life around. But nothing will ever change. That cycle of mediocrity isn't due to some obstacle. It's who you are. The thing standing in the way of your dreams is; that the person having them is you.
A male author is insisting that he is living proof that it's possible for a male author to write an authentic female protagonist.— Gwen C. Katz (@gwenckatz) 30 mars 2018
Here's a quote from his first page. pic.twitter.com/f6d5bN2EHq
proc Real c {lindex $c 0}
proc Imag c {lindex $c end}
proc Add {c d} {
lmap c $c d $d {expr {$c + $d}}
}
proc String c {
if {[lindex $c end] < 0} {
format (%g%gi) {*}$c
} else {
format (%g+%gi) {*}$c
}
}
set z {1 2}
String [Add $z $z]
oo::class create Complex {
variable re im
constructor args {
lassign $args re im
if {$re != $re || $im != $im} {
set msg {domain error: argument not in valid range}
throw [list ARITH DOMAIN $msg] $msg
}
}
method real {} {set re}
method imag {} {set im}
method add d {
Complex new [expr {$re + [$d real]}] [expr {$im + [$d imag]}]
}
method string {} {
if {$im < 0} {
format (%g%gi) $re $im
} else {
format (%g+%gi) $re $im
}
}
}
set z [Complex new 1 2]
[$z add $z] string
namespace eval oo::define {
proc attr {access args} {
set class [lindex [info level -1] 1]
::oo::define $class variable {*}$args
if {"reader" in $access} {
foreach name $args {
::oo::define $class method $name {} \
[format {set %s} $name]
}
}
if {"writer" in $access} {
foreach name $args {
::oo::define $class method $name= v \
[format {set %s $v} $name]
}
}
}
interp alias {} attr_reader {} ::oo::define::attr reader
interp alias {} attr_writer {} ::oo::define::attr writer
interp alias {} attr_accessor {} ::oo::define::attr {reader writer}
}
In my experience, the best programming languages for just writing programs are those which have "the structure of water" as a zen enthusiast I once knew explained it. They can be deformed infinitely, without stress, to fit the shape their environment requires.
So, yes, I really and truly do prefer a multiparadigm language with a reasonably small, general working vocabulary, that doesn't make design choices for me. I like languages where object-oriented and functional programming (and imperative, and stream-oriented, and data-directed, etc) are all Things You Can Do rather than being The Only Way The Language Works.
Looking back on my own programming career, I find that the languages I have liked best (Lisp, C, Tcl) are very much like this description. The languages I have tried and given up on (Perl, Java, Python, C++) are more or less the opposite (Perl and C++ were designed to fit any user, but grew to be unwieldy and demanding).
The classic first demonstration program.
pack [button .b -text "Hello, world!" -command exit]
In a Tcl/Tk shell such as wish, this program creates a window and places a plain, unstyled button on it. The text on the button is "Hello, world!" and when you click the button, the program exits.
If you just want to print the text inside the shell, try
puts "Hello, world!"
The challenge is as follows.
1) Pick out code5, the second part of the last word on the last line of this data file:
line1 1 2 3 4 5 end-code1-line line2 2 2 3 4 5 end-code2-line line3 3 2 3 4 5 end-code3-line line4 4 2 3 4 5 end-code4-line line5 5 2 3 4 5 end-code5-line
2) Do so by executing commands written sequentially ("pipelining" the data from one command to the next).
What we need to do is to read the data from the file, remove ("trim") whitespace from the beginning and end of it, split it into lines, pick the last line, split it into words, pick the last word, split it at the dashes, choose the second element of it.
The most natural way to solve this in Tcl is something like
package require fileutil set data [string trim [::fileutil::cat lines.txt]] set line [lindex [split $data \n] end] set word [lindex [split $line] end] lindex [split $word -] 1
This is not written in sequential order. The first command to be executed on each line is the one in the innermost brackets, then the command in the enclosing set of brackets, and so on.
The same code in sequential order looks like this:
package require fileutil set v lines.txt set v [::fileutil::cat $v] set v [string trim $v] set v [split $v \n] set v [lindex $v end] set v [split $v] set v [lindex $v end] set v [split $v -] lindex $v 1
This works, but this is Tcl. We can abstract away a lot of detail here.
One idea is to enumerate the commands to be applied to the data and execute them in a loop:
proc seq {v cmds} {
foreach cmd $cmds {
set v [{*}$cmd $v]
}
set v
}
seq lines.txt {::fileutil::cat {string trim}}
But that only works as far as the string trim. The next command, to split the lines, requires a second argument.
We can solve that by creating command aliases:
interp alias {} lines {} apply {v {split $v \n}}
interp alias {} words {} split
interp alias {} last {} apply {v {lindex $v end}}
One of those, words, is unnecessary since that invocation doesn't need any further argument. It makes the code a bit clearer, though.
The other aliases work by rewriting invocations: the invocation last {a b c} is rewritten as lindex {a b c} end and so on.
Now we can perform the processing as far as seq lines.txt {::fileutil::cat {string trim} lines last words last}. The last two commands could have been aliased the same way, but let's be a bit more creative. If we define the convention that a command that contains the character / has an attached argument, we can let our code do the same rewriting as the aliases do.
proc seq {v cmds} {
foreach cmd $cmds {
if {[string match */* $cmd]} {
set cmd [list apply [list v [regsub / $cmd { $v }]]]
}
set v [{*}$cmd $v]
}
set v
}
The if looks a little busy, but it's actually quite straightforward. The condition is that if $cmd contains a slash character somewhere (the asterisks state that there may be, but doesn't have to be, characters before and after the slash). Then a regsub command replaces that slash with the text { $v }, i.e. space, dollar, v, space. The resulting string is wrapped in a list with the text v as first element, and then that is wrapped in a list with apply as first element. The result becomes the rewritten command: if we had lindex/end, we now have {apply {v {lindex $v end}}}, which can be executed by set v [{*}$cmd $v].
And we can finally write the procedure sequentially. Compare with the second program above.
seq lines.txt {
::fileutil::cat
{string trim}
lines
last
words
last
split/-
lindex/1
}
I read a blog post today, A Short Story About Verbosity, about writing a tech book. The publisher had asked the writer to go for at least 600 pages. I was reminded of a joke I used to make back when I was teaching C and C++. I would plop down the 272-page The C Programming Language on the desk and say "This is an exhaustive description of C". Then I'd let the ~980-page "The C++ Programming Language" fall with a sickening thud and say "This is the bare minimum you need to understand C++". (Don't worry, I didn't leave them with that: there are shortcuts into C++, and I did my best to point them out.)
Many times you can't really avoid verbosity in a tech book. In the best case, this is because the subject is extensive. In the worst case, it's because the subject is humongous.
I still hope to be able to take my programming book from plans to reality one day. Whatever it becomes, it won't be thick. I'd be surprised if it's more than 300 pages. If I can't say what I want to say in less pages than that, maybe I shouldn't bother. That might mean that no publisher will be interested, but there are other ways.
#!/usr/bin/perl
use strict;
use Tk;
my $mw = MainWindow->new;
$mw->Button(-text => 'First Button',
-command => sub { print "You hit the First Button.\n" }
)->pack;
$mw->Button(-text => 'Second Button',
-command => \&second_sub,
)->pack;
$mw->Button(-text => 'QUIT',
-command => \&exit,
)->pack;
MainLoop;
sub second_sub
{
print "The Second Button invokes a Named Subroutine.\n";
return;
}
