Software engineering and civil engineering have little in common. But should software engineers be more like their civil counterparts? A panel of software development experts explores the issues.

Tyler Herro may never be missed more than in the Eastern Conference semifinals against the New York Knicks. But there still is a way for the Miami Heat to keep it rolling in the NBA playoffs.

Can better airflow create opportunities for energy savings and building materials longevity that roofing contractors often miss?

Host Bob Leins, CPA® welcomes John Jilek, CFP®.

The post Roth vs. Traditional IRA and Roth TSP vs. Pre-tax TSP and a Perspective on RMDs first appeared on Federal News Network.

Knowing the differences between threats can lead to more nuanced conversations about which security measures clients should invest in, writes Barracuda MSP's Chris Crellin.

Jason Snell returns to the show to discuss Apple's September product announcements, and Meta's Orion prototype AR glasses.

En este episodio, La Luciérnaga se enciende para hablar de la
liquidación de la cadena de tiendas Justo & Bueno. Además, le pone la lupa
a la pelea entre los senadores Armando Benedetti y Carlos Felipe Mejía.
También, el Papa Francisco expresó su preocupación por la tendencia a no tener
hijos. 



La
Luciérnaga un espacio de humor análisis y opinión de Caracol Radio que acompaña
desde hace 30 años a sus oyentes en el regreso a casa.

La Luciérnaga se enciende para hablar de los problemas de orden público en el Caquetá. Además, le contamos sobre el enfrentamiento entre el presidente Gustavo Petro y su homónimo en El Salvador, Nayib Bukele. También, celebramos 31 años de una mezcla extraña de realidad y ficción.La Luciérnaga, un espacio de humor, análisis y opinión de Caracol Radio que acompaña desde hace 30 años a sus oyentes en el regreso a casa.

En la previa del juego en Ibagué, El Alargue analiza lo que será una final que define al nuevo campeón de Colombia, como siempre, con los mejores invitados.

En este episodio de El Alargue hablamos sobre los bochornosos hechos en Ibagué contra Daniel Cataño y entrevistamos con el padre de Alejandro Montenegro, quien agedió por la espalda al volante de Millonarios.

Elvira Kurt and Graham Chittenden have no time to waist when they discuss if belts are superior to suspenders. Then, should everyone move to Hamilton? Gavin Stephens and Ron Sparks bring the Hammer down on each other in their debate for this Ontario city.

Derek Seguin and Chad Anderson grow the generation gap when they discuss if Gen Xers are the best age group. Then, Hisham Kelati and Kathleen McGee have a spirited debate on whether angels are superior to ghosts.

The Debaters’ season finale episode is creating a buzz! Charlie Demers and Derek Seguin sweet talk the audience when they debate if maple syrup is superior to honey. Then, Henry Sir and Erica Sigurdson are ready for a pillow fight when they discuss if nothing’s more fun than a sleepover.

It’s the premiere of The Debaters’ 19th season and this is one for the bever-ages! Dave Hemstad and Lisa Baker are in Newfoundland trying to burst each other’s bubble when they decide if Coke is superior to Pepsi. Then, are family doctors overrated? Clifton Cremo and Martha Chaves checkup on these medical professionals.

Matt Wright and Charlie Demers make waves in St. John’s, Newfoundland when they discuss if the Atlantic Ocean is superior to the Pacific Ocean. Then, Bree Parsons and Nikki Payne bring a wealth of wit when they decide if growing up poor makes you a stronger person.

Myles Anderson and Sean Lecomber troll with the punches when they discuss whether kids should use social media. Then, are stripes superior to polka dots? Rob Pue and Kathleen McGee refuse to be clothed-minded with their patter on these patterns.

Is butter better than margarine? Derek Seguin and Matt Wright churn out jokes in a battle for the superior spread. Then, Nour Hadidi and Hisham Kelati get in the zone when they decide if Newfoundland has the best time zone.

Charlie Demers and Lisa Baker are anything but fake when they discuss if it's okay to ignore the news. Then, are windows superior to doors? Graham Clark and Charles Haycock tear a weather-strip off each other in this architectural argument.

YouTuber-turned-boxer Jake Paul had to wait an extra four months for his high-profile match with 58-year-old former heavyweight champion Mike Tyson.

Q: What time is it at Ball Arena right now? A: Four past Georgiev.

Gut-wrenching because of how the Broncos (5-5) found themselves on victory’s doorstep.

Broncos' loss sure does feed into NFL fans' conspiracy theories about the Kansas City Chiefs.

If Jarrett Stidham is the quarterback under center for the Broncos in 2024, will coach Sean Payton be on the hot seat this time next year?

With little wiggle room against the NFL salary cap, how real is the possibility that the Broncos will have to say goodbye to a significant contributor or two in free agency?

Although Colorado women’s basketball coach JR Payne knew she was going to have an almost completely new roster this year, she was encouraged by several qualities the group possessed.

Why Bill Adler followed The Message.

And the first Grammy for a hip hop act went to…

Don't judge a book by its cover.

Hidden sources reveal true character.

Backs against the wall and jobs on the line.

Season 2, Act I of "Arcane," the animated series based on the popular multiplayer online battle arena game League of Legends, also had a strong debut, taking second place with 6.3M views.

In recent weeks and months, we've been having many posts and comments about Taiwanese language.  Today's post is quite different:  it's all about the difference between Mandarin as spoken on the mainland and as spoken on Taiwan. "Words of Influence: PRC terms and Taiwanese identity", by Karen Huang, Taiwan Insight (8 November 2024) What is […]

It's no secret that I'm an aficionado of Lisp. It's my go to language, especially when I don't know what I'm doing. I call it research and prototyping, but it's really just playing around until something works.

We had a need for some auditing of some of our databases at work. They ought to agree with each other and with what GitHub and CircleCI think. It took a couple of weeks part time to prototype a solution in Common Lisp. It showed that the databases were in 99% agreement and found the few points of disagreement and anomalies that we ought to fix or look out for.

I want to integrate this information into a dashboard on one of our tools. I prototyped this by spinning up a Common Lisp microservice that returns the information in JSON format.

But management prefers that new services are written in golang. It would be easier for me to rewrite the service in golang than to try to persuade others to use Common Lisp. It also gives me the opportunity to compare the two languages head to head on a real world problem.

No, this is not a fair comparison. When I wrote the Lisp code I was exploring the problem space and prototyping. I'm much more experienced with Lisp than with golang. The golang version has the advantage that I know what I want to do and how to do it. In theory, I can just translate the Common Lisp code into golang. But then again, this is a “second system” which is not a prototype and has slightly larger scope and fuller requirements. So this cannot be a true head to head comparison.

The first point of comparison is macros (or lack thereof). I generally don't use a lot of macros in Common Lisp, but they come in handy when I do use them. One macro I wrote is called audit-step, which you can wrap around any expresion and it prints out a message before and after the expression is evaluated. The steps are numbered in sequence, and nested steps get nested numbers (like step 2.3.1). If you wrap the major function bodies with this macro, you get a nice trace of the call sequence in the log.

Golang doesn't have macros, but it has first class functions. It's easy enough to write a function that takes a function as an argument and wraps it to output the trace messages. In fact, the macro version in Common Lisp just rewrites the form into such a function call. But the macro version hides a level of indentation and a lambda. In golang, my major functions all start with

func MajorFunction (args) int {
        return AuditStep("MajorFunction", "aux message", func() int {
                // body of MajorFunction
                // Actual code goes here.
        })    
}

The bodies of all my major functions are indented by 16 spaces, which is a little much.

I like higher order functions. I can write one higher order function and parameterize it with functions that handle the specific cases. In my auditing code, one such workhorse function is called collate. It takes a list of objects and creates a table that maps values to all objects in the list that contain that value. To give an example, imaging you have a list of objects that all have a field called foo. The foo field is a string. The collate function can return a table that maps strings to all objects that have that string in the foo field.

collate is very general. It takes a list of objects and four keyword arguments. The :key argument is a function that extracts the value to collate on. The :test argument is a function that compares two keys (it defaults to eql if not specified). The :merger argument is a function to add the mapped object to its appropriate collection in the table (it defaults to adjoin). The :default argument specifies the initial value of a collection in the table (it defaults to nil).

The :merger function is the most interesting. It takes the key and the object and the current value of the table at that key. It returns the new value of the table at that key. The default merger function is adjoin, which adds the object to the collection at the key if it is not already there. But you can specify a different merger function. For example, if you want to count the number of objects at each key, you can specify a merger function that increments a counter.

The functional arguments to the collate function are often the results of other higher order functions. For example, the :key argument is often the result of composing selector functions. The :merger argument is often the result of composing a binary merge function with a unary transformer function. The transformer function is often the result of composing a number of primitive selectors and transformers.

In Common Lisp, it is quite easy to write these higher order functions. We can compose two unary functions with the compose2 function:

(defun compose2 (f g)
  (lambda (x) (funcall f (funcall g x)))

and then compose as many functions as we like by fold-left of compose2 starting with the identity function:

(defun compose (&rest fs)
  (fold-left #'compose2 #'identity fs))

We can compose a binary function with a unary function in three ways: we can pipe the output of the binary function into the unary function, or we can pipe the output of the unary function into one or the other of the inputs of the binary function.

(defun binary-compose-output (f g)
  (lambda (x y) (funcall f (funcall g x y))))

(defun binary-compose-left (f g)
  (lambda (x y) (funcall f (funcall g x) y)))

(defun binary-compose-right (f g)
  (lambda (x y) (funcall f x (funcall g y))))

The collate function can now assume that a lot of the work is done by the :key and :merger functions that are passed in. It simply builds a hash table and fills it:

(defun collate (item &key (key #'identity) (test #'eql) (merger (merge-adjoin #'eql)) (default nil))
  (let ((table (make-hash-table :test test)))
    (dolist (item items table)
      (let ((k (funcall key item)))
        (setf (gethash k table) (funcall merger (gethash k table default) item))))))

(defun merge-adjoin (test)
  (lambda (collection item)
    (adjoin item collection :test test)))

So suppose, for example, that we have a list of records. Each record is a three element list. The third element is a struct that contains a string. We want a table mapping strings to the two element lists you get when you strip out the struct. This is easily done with collate:

(collate records
  :key (compose #'get-string #'third)
  :test #'equal      ; or #'string= if you prefer
  :merger (binary-compose-right (merge-adjoin #'equal) #'butlast))

The audit code reads lists of records from the database and from GitHub and from CircleCI and uses collate to build hash tables we can use to quickly walk and validate the data.

Translating this into golang isn't quite so easy. Golang has first class function, true, but golang is a statically typed language. This causes two problems. First, the signature of the higher order functions includes the types of the arguments and the return value. This means you cannot just slap on the lambda symbol, you have to annotate each argument and the return value. This is far more verbose. Second, higher order functions map onto parameterized (generic) types. Generic type systems come with their own little constraint language so that the computer can figure out what concrete types can correctly match the generic types. This makes higher order functions fairly unweildy.

Consider compose2. The functions f and g each have an input and output type, but the output type of g is the input type of f so only three types are involved

func Compose2[T any, U any, V any](f func(U) V, g func(T) U) func(T) V {
	return func(x T) V {
		return f(g(x))
	}
}

If want to compose three functions, we can write this:

func Compose3[T any, U any, V any, W any](f func(V) W, g func(U) V, h func(T) U) func(T) W {
	return func(x T) W {
		return f(g(h(x)))
	}
}

I don't see a way to write an n-ary compose function. It would have to be dynamically parameterized by the intermediate types of all the functions it was composing.

For the collate function, we can write this:

func Collate[R any, K comparable, V any](
	list *Cons[R],
	keyfunc func(R) K,
	merger func(V, R) V,
	defaultValue V) map[K]V {
	answer := make(map[K]V)
	for list != nil {
		key := keyfunc(list.Car)
		probe, ok := answer[key]
		if !ok {
			probe = defaultValue
		}
		answer[key] = merger(probe, list.Car)
		list = list.Cdr
	}
	return answer
}

We have three types to parameterize over: the type of the list elements (i.e. the record type) R, the type of the key K, and the type of the value V. The key type is needs to be constrained to be a valid key in a map, so we use the comparable constraint. Now that we have the types, we can annotate the arguments and return value. The list we are collating is a list of R elements. The key function takes an R and returns a K. The merger takes an existing value of type V and the record of type R and returns a new value of type V.

The magic of type inference means that I do not have to annotate all the variables in the body of the function, but the compiler cannot read my mind and infer the types of the arguments and return value. Golang forces you to think about the types of arguments and return values at every step of the way. Yes, one should be aware of what types are being passed around, but it is a burden to have to formally specify them at every step. I could write the Common Lisp code without worrying too much about types. Of couse the types would have to be consistent at runtime, but I could write the code just by considering what was connected to what. In golang, the types are in your face at every function definition. You not only have to think about what is connected to what, you have to think about what sort of thing is passed through the connection.

I'm sure that many would argue that type safety is worth the trouble of annotation. I don't want to argue that it isn't. But the type system is cumbersome, awkward, and unweildy, especially when you are trying to write higher order functions.

It is taking me longer to write the golang version of the audit service than it did to write the Common Lisp version. There are several reasons. First, I am more experienced with Common Lisp than golang, so the right Common Lisp idioms just come to mind. I have to look up many of the golang idioms. Second, the golang code is trying to do more than the Common Lisp code. But third, golang itself introduces more friction than Common Lisp. Programs have to do more than express the algorithm, they have to satisfy the type system.

There are more points of comparison between the two languages. When I get frustrated enough, I'll probably write another post.

[BULLETIN: Quicklisp now has the latest version of FSet.]

Sycamore, primarily by Neil Dantam, is a functional collections library that is built around the same weight-balanced binary tree data structure (with leaf vectors) that FSet uses.  While the README on that page comments briefly on the differences between Sycamore and FSet, I don't feel that it does FSet justice.  Here is my analysis.

Dantam claims that his library is 30% to 50% faster than FSet on common operations.  While I haven't done comprehensive micro-benchmarking, a couple of quick tests indicates that this claim is plausible.  A look through the internals of the implementation confirms that it is clean and tight, and I must commend him.  There may be some techniques in here that I could usefully borrow.

Most of the performance difference is necessitated by two design choices that were made differently in the two libraries.  One of these Dantam mentions in his comparison: FSet's use of a single, global ordering relation implemented as a CLOS generic function, vs. Sycamore's more standard choice of requiring a comparison function to be supplied when a collection is created.  The other one he doesn't mention: the fact that FSet supports a notion of equivalent-but-unequal values, which are values that are incomparable — there's no way, or at least no obvious way, to say which is less than the other, and yet we want to treat them as unequal.  The simplest example is the integer 1 and the single-float 1.0, which have equal numerical values (and cl:= returns true on them), but which are nonetheless not eql.  (I have a previous blog post that goes into a lot more detail about equality and comparison.)  Since Sycamore expects the user-supplied comparison function to return an integer that is negative, zero, or positive to indicate the ordering of its arguments, there's no encoding for the equivalent-but-unequal case, nor is there any of the code that would be required to handle that case.

Both of these decisions were driven by my goal for the FSet project.  I didn't just want to provide a functional collections library that could be called occasionally when one had a specific need for such a data structure.  My ambition was much grander: to make functional collections into a reasonable default choice for the vast majority of programming situations.  I wanted FSet users (including, of course, myself) to be able to use functional collections freely, with very little extra effort or thought.  While Lisp by itself reaches a little bit in this direction — lists can certainly be used functionally — lists used as functional collections run into severe time complexity problems as those collections get large.  I wanted the FSet collections to be as convenient and well-supported as lists, but without the time complexity issues.

— Or rather, I wanted them to be even more convenient than lists.  Before writing FSet, I had spent years working in a little-known proprietary language called Refine, which happened to be implemented on top of Common Lisp, so it was not unusual to switch between the two languages.  And I had noticed something.  In contrast to CL, with its several different predefined equality predicates and with its functions that take :test arguments to specify which one to use, Refine has a single notiion of equality.  The value space is cleanly divided between immutable types, which are compared by value — along with numbers, these include strings, sets, maps, and seqs — and mutable objects, which are always compared by identity.  And it worked!  I found I did not miss the ability to specify an equality predicate when performing an operation such as "union".  It was just never needed.  Get equality right at the language level, and the problem goes away.

Although FSet's compare generic function isn't just for equality — it also defines an ordering that is used by the binary trees — I thought it would probably turn out to be the case that a single global ordering, implemented as a generic function and therefore extensible, would be fine the vast majority of the time.  I think experience has borne this out.  And just as you can mix types in Lisp lists — say, numbers and symbols — without further thought, so you can have any combination of types in an FSet set, effortlessly.  (A project I'm currently working on actually takes considerable advantage of this capability.)

As for supporting equivalent-but-unequal values, this desideratum flows directly from the principle of least astonishment.  While it might not be too surprising for a set or map implementation to fail distinguish the integer 1 from the float 1.0, it certainly would be very surprising, and almost certainly a source of bugs in a compiler that used it, for it to fail to distinguish two uninterned symbols with the same name.  (I saw a macro expansion recently that contained two distinct symbols that both printed as #:NEW.  It happens.)  A compiler using Sycamore for a map on symbols would have to supply a comparison function that accounted for this; it couldn't just compare the package name and symbol name.  (You'd have to do something like keep a weak hash table mapping symbols to integers, assigned in the order in which the comparison function encountered them.  It's doable, but FSet protects you from this madness.)

Along with those deep semantic design choices, I've spent a lot of time on developing a wide and featureful API for FSet (an effort that's ongoing).  FSet has many features that Sycamore lacks, including:

• seqs, a binary-tree sequence implementation that holds arbitrary Lisp objects (Sycamore ropes hold only characters, which is certainly an important special case, but why restrict ourselves?)
• default values for maps and seqs (the value to return when the key is outside the domain is associated with the collection, not supplied at the call site; this turns out to be a significant convenience)
• generic functions that operate on both lists and FSet collections, to shadow the CL builtins
  
• the powerful map-union and map-intersection operations (I'll blog about these in the future)
• more ways to iterate over the collections (the FSet tutorial has a good summary, about 3/4 of the way down)
• speaking of the tutorial, FSet has lots more documentation

Let me digress slightly to give an example of how FSet makes programming more elegant and convenient.  Joe Marshall just put up a blog post comparing Go(lang) with Common Lisp, which is worth a read on its own; I'm just going to grab a code snippet from there to show a little bit of what programming with FSet is like.  Here's Joe's code:

 (defun collate (items &key (key #'identity) (test #'eql) (merger (merge-adjoin #'eql)) (default nil))
   (let ((table (make-hash-table :test test)))
     (dolist (item items table)
       (let ((k (funcall key item)))
         (setf (gethash k table) (funcall merger (gethash k table default) item))))))

 (defun merge-adjoin (test)
   (lambda (collection item)
     (adjoin item collection :test test)))

And here's what I would write using FSet:

(Well, I would probably move result outside the dolist form to make it clearer what the return value is, but let's go with Joe's stylistic choice here.)

For those who haven't used FSet: the form (map :default (set)) creates a map whose default is the empty set, meaning that lookups on that map will return the empty set if the key is not in the map.  This saves the includef form from having to handle that possibility.

My version makes assumptions, it's true, about how you want to collect the items with a given key; it doesn't give you other choices.  It could, but what would be the point?  It's already using a general set with better time complexity than lists, and saving you from having to write anything like merge-adjoin.  The extensible global equivalence relation means you're not going to need to supply a :test either.

I think the FSet-enhanced code is cleaner, more elegant, and therefore clearer than the plain-CL version.  Don't you agree?  Maybe you wouldn't say it's a huge improvement, okay, but it's a small example; in a larger codebase, I would argue, these small improvements add up.

* * * * *

To summarize: if you just want a library you can call in a few places for specific purposes, Sycamore might work better for you (but think hard if you're writing a comparator for symbols).  FSet can certainly be used that way, but it can be much more.  If you want to see one way in which Common Lisp can be made into a better language, without giving up anything that we love about it, I urge you to give FSet a try.

FSet has changed the way I write Lisp programs.  — an FSet user

(UPDATE: the magnitude of the performance difference between FSet and Sycamore surprised me, and inspired me to do some profiling of FSet.  It turned out that I could get a 20% speedup on one micro-benchmark simply by adding some inline declarations.  Mea culpa, mea culpa, mea maxima culpa; I should have done this years ago.   With that change, the generic function overhead appears to be the only significant cause of the remaining ~20% performance difference.  I tried creating a Sycamore set using a thin wrapper around fset:compare, and the resulting performance was very similar to that of FSet with its new inlines.)

Providence Friars' Oswin Erhunmwunse threw down a powerful two-handed dunk against the Hampton Pirates.

Providence Friars' Bensley Joseph found Corey Floyd Jr. for a tough alley-oop dunk against the Hampton Pirates.

John Hugley IV recodrded a NASTY block to help Xavier hold on to 40-25 lead at halftime vs. Jackson State

1. “Wir müssen uns von der Vorstellung lösen, dass Journalismus gleichbedeutend mit Content ist” (journalist.de, Leif Kramp & Stephan Weichert) Bei journalist.de ist ein lesenswertes Interview mit dem US-amerikanischen Journalismus-Experten Jeff Jarvis erschienen, der gleich in der ersten Antwort ziemlich direkt wird: “Während wir die US-Wahlen durchlaufen, frage ich mich, ob es Zeit ist, den […]

Imagine slipping into a tranquil space, the soft aroma of essential oils filling the air, as the world outside slowly fades away. For many, this is the sanctuary sought after a long week of work or dealing with chronic pain. In that moment, whether it’s the gentle caress of a Swedish massage or the deep ... Read more

The post Swedish vs. Deep Tissue – Which Massage Will Leave You More Bruised? appeared first on Star Two.

At an Arizona tribal school, it's a fierce campaign to pick the top school lunch, as students learn about making their voice count

Forbes.com published an article by Dan Woods where he describes a battle between the traditional enterprise software providers (Microsoft, SAP, and Oracle) and Saas providers like Salesforce.com and NetSuite.

According to Woods, SaaS applications are easier to use because they offer streamlined interfaces that are modeled after successful web consumer sites like Amazon.com, Yahoo!, eBay, Google, etc. These SaaS interfaces were designed to be easily configurable.

Traditional enterprise software is not as easy to use because user interfaces are often created before it is known exactly how the software would be used. Customization to the user interface is often done at installation by systems integrators who do not have any actual user behavior on which to base their customizations.

The Big Three are well aware of the usability gap between their products and SaaS software, but it is unclear how to solve the problem. Oracle emphasizes Fusion as an integration platform. SAP recently announced an experiment called Blue Ruby that is attempting to adapt Ruby on Rails as a user interface and programming technology for its applications. But is it possible to affordably automate a business starting with a configurable application platform that must be adapted to the specific user interfaces and business processes in a company? The SaaS model starts with a usable interface and a working automation of common processes, and then has the configuration proceed from there. The hosted nature of SaaS removes the deployment barriers.

14 July 2020

Alex Ovechkin calmly slid into the right circle and sniped a snapshot past a blinded Juuse Saros to lead the Washington Capitals to a 3-2 triumph over the Nashville Predators.

Chet Holmgren's 7-foot-1 frame crashed to the floor, resulting in a pelvic bone break and an early exit during an Oklahoma City Thunder loss to the Golden State Warriors.

In this GPU age, CPUs are often considered second citizens because most of the performance comes from the GPU. In most systems, GPUs are separate PCIe devices used by the […]

The post Xeon 6 vs. Zen-5 HPC Benchmark Showdown appeared first on HPCwire.