The Sleepless King, новое видео MARBLE, доступно для просмотра ниже.
#Marble
Видео: https://www.youtube.com/watch?v=Q2LVOUSB4as

Дэн Фэллоуз оставляет пост технического директора Aston Martin F1 – как сообщает пресс-служба команды, это произойдёт уже в ноябре...

The newspaper industry has faced a mighty challenge over the last few years. There is so much “free” content to complete with them. Newspaper revenue continues to plummet. Internet users are reluctant to pay for content. All the free content, supported by advertising revenue, has decimated the newspaper industry. The industry’s cousin, the magazine industry, is not far behind.

This trend can’t continue forever. Already, many people are asking themselves how much they can trust the information on the internet. The need for Reliability drives the demand for Snopes.com. How many “free” web sites can earn enough from advertising to pay all their bills? An effective industry answer to “free” may be forthcoming in the News Corp online newspaper called “The Daily.” The Daily will cover general news, sports, arts and opinion in a format dedicated to the Apple iPad. In addition to the written content, the product will carry high definition video and 360 degree photos. The same product will be available in a few months for the Android-based tablet computers.

The Daily will sell for $.99 a week, or $39.99 a year, a very low price compared to newspapers. With this model, the product receives revenues both from the subscribers and from advertisers. Subscribers have the Reliability benefit of knowing that the content producer cares about facts, accuracy and readable writing style. Advertisers pay for eyeballs that follow a Reliable product.

The Daily is what we call a Next Leader product. This is a product that offers much better than industry standard performance for a low price to a specific subset of industry customers. The Next Leader can offer the very low price because it has a much lower cost structure than is typical in the industry. There are two basic types of Next Leaders. The first are Reformer products. This type of Next Leader product reduces the benefits for the user (usually Function benefits) while increasing the benefits for the buyer (usually Reliability and Convenience benefits) compared to the industry Standard Leader product. The second of the two types of Next Leader products are Transformer products. These products increase the benefits of the user but offer, at least initially, fewer benefits to the buyer than the Standard Leader product offers. The Daily is a Reformer product. It offers the Convenience of formatting fit for a tablet computer so it provides easier access for a segment of the industry’s customers. Its low cost structure results from its elimination of printing presses and distribution costs.

If this new tablet-based product offers a quality read, it will hasten the day when virtually every newspaper and magazine is offered first online and only secondarily in hard copy. The online versions will come at a fraction of the cost of the hard copy versions. Readership is certain to grow.

REVIEW – One of the nice experiences when buying a new smartphone is choosing nice cases that are not only attractive but provide protection and create a good gripping surface. Let’s see how this Smartish Gripzilla iPhone 16 Pro Max case works for me. What is it? The Smartish Gripzilla iPhone 16 Pro Max case […]

REVIEW – My first smartwatch was the Pebble, which I found to be instantly invaluable by displaying my notifications right on my wrist and then letting me decide if they were important enough to pull my phone out. For me, this has been the primary function of my smartwatches to this day. Other functions and […]

NEWS – Govee Smart Space Heaters are being recalled due to fire and burn risks. We’ve reviewed many Govee products here including the H7135 and the H7134. Govee says the listed models do not pass the UL safety standard and they are voluntarily recalling these smart space heater models. Recall details are at the Govee […]

NEWS – Scykei Technology, Inc., a New York-based tech brand, announced its mission to challenge the status quo and redefine the technology industry. With a bold vision to become a generation-defining tech company, Scykei is poised to make waves in the wearable market. Positioning: A Considerable Alternative Scykei has positioned itself as a considerable alternative […]

In the latest episode of their intrepid podcast, Ken and Robin talk Sense Trouble, fatbergs, William Stephenson, and doomsday predictor Albert Porta.

For those actively following the World's news, here is our monthly quick reference to National Geographic maps which add perspective to today's news stories.

WORLD

The 8.8 Magnitude earthquake in Chile, has left substantial devastation to the port town on Concepcion and left thousands homeless in the Capital city of Santiago. Our recently updated South America Wall Map contains place names for most major and secondary cities, plus physical features, and major transportation networks.



When I first heard about the Tsunami threat for the Hawaiian Islands, Australia, Japan and the islands of the Pacific on Saturday, I turned to our World Pacific Centered wall map. Unlike the wall map you likely had hanging in your classroom, which was Atlantic Ocean centered, our Pacific Centered edition provides a seamless view of the entire Ocean. This different perspective made it easier to understand the path of the Tsunami waves and helped clarify why places such as the California, Oregon and Washington coasts were under the warning as well.

Beyond the Chilean earthquake, this winter seems especially harsh, and on Sunday, France and four other countries were battered by a deadly storm named "Xynthia". In its wake the storm left 51 dead, millions without power, and generated extensive property damage throughout the region. Winds in excess of 130MPH were recorded over the Pyrenees with 100 MPH gusts along the Atlantic coast. National Geographic has a collection of up-to-date reference maps for most of the countries in Europe including: France, Belgium & The Netherlands, Spain & Portugal, and Germany. Additionally we recently revised our Europe wall map, which is available in several styles.


US

Here on the home front, winter weather continued to make headlines last week with the Northeast receiving another record breaking snowfall. National Geographic publishes a wide variety of United States Wall Maps, varying in style, size, and format that will assist with following nearly any US based news story.

The Tsunami warning for the Hawaiian Islands last Saturday had me turning to one of our most beautiful wall maps, The Hawaiian Islands, which exposes the dramatic terrain of the ocean floor around the island chain.




SPORTS

Now that the Winter Olympics have concluded, it's time to turn our eyes south to Arizona and Florida as MLB Spring Training kicks off today. If you're heading to watch any of the games, we have two useful maps for your glovebox, the Florida State Guide Map and the Arizona State Guide Map. Both maps have up-to-date road networks for the State, plus detailed inset maps for the major cities, like the Spring Training hubs of Tampa, Ft. Myers, Scottsdale and Tucson. While I'm a big fan of GPS for turn-by-turn directions, sometimes its just a little faster to use a real map, and you certainly get a better perspective of what's ahead when on a road trip.



As always - we love to hear your comments, questions and ideas for future posts.

1. Apple reportedly releasing a wall-mounted smart home tablet in 2025 - and yes, it does AI  Yahoo Finance Australia
2. Apple’s next device might make your home a lot smarter  Sydney Morning Herald
3. Apple's Next Big Move Could Be Home Security Cameras  PCMag AU

Philanthropy online has recently published an article on the initial charitable response to the cyclone disaster in Burma. unfortunately bureaucratic red tape has slowed the initial response some; numerous organizations are preparing a herculean response that will save lives, and perhaps improve the domestic situation in Myanmar over the long term.

Events like these confirm the importance of fund-raising in general and telephone fund-raising specifically. Its one thing to hear about a tragedy on television and remind oneself to try and make a donation. Its quite another to receive a phone call as a situation is unfolding and have an opportunity to directly influence the outcome of that situation.

I participated in campaigns after hurricanes Rita and Katrina. I also worked on the campaign to provide relief to the victims of the Asian Tsunami, and issue of personal significance to me as I lived for many years in Indonesia. It is in times like this when innovative fund raising strategies can truly make a significant difference by fully funding humanitarian emergency relief efforts before a crisis can intensify.

There is nothing like a call to action.

If passed, it would be the first standalone NASA authorization since 2017.

A single 3.5 billion-year-old rock shows signs of all the conditions life needs to thrive.

A big rover makes a big find on Mars. Little rovers have their place in exploration, too.

The tentative discovery hints at an habitat where life could potentially thrive.

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.

A comment on my previous post said,

The most difficult thing when coming to a different language is to leave the other language behind. The kind of friction experienced here is common when transliterating ideas from one language to another. Go (in this case) is telling you it just doesn't like to work like this.

Try writing simple Go, instead of reaching for Lisp idioms. Then find the ways that work for Go to express the concepts you find.

That's not at all how I approach programming.

A friend of mine once paid me a high compliment. He said, “Even your C code looks like Lisp.”

When I write code, I don't think in terms of the language I'm using, I think in terms of the problem I'm solving. I'm a mostly functional programmer, so I like to think in terms of functions and abstractions. I mostly reason about my code informally, but I draw upon the formal framework of Lambda Calculus. Lambda Calculus is a simple, but powerful (and universal) model of computation.

Programming therefore becomes a matter of expressing the solution to a problem with the syntax and idioms of the language I'm using. Lisp was inspired by Lambda Calculus, so there is little friction in expressing computations in Lisp. Lisp is extensible and customizable, so I can add new syntax and idioms as desired.

Other languages are less accommodating. Some computations are not easily expressable in the syntax of the language, or the semantics of the language are quirky and inconsistent. Essentially, every general purpose fourth generation programming language can be viewed as a poorly-specified, half-assed, incomplete, bug-ridden implementation of half of Common Lisp. The friction comes from working around the limitations of the language.