Digital minimalism

analogify.jpgHyper self-digitalization is not healthy like any other extreme,   this is my observation, there are ways how to reduce it and since this is very new area of research it will take cca another decade to educate society on digital hygiene.  Meanwhile there are already some good books available –  Cal Newport’s Book : “Digital Minimalism”.

One of my first attempt was in 2013 so time to renew the effort.

Here is my “analogue” / d.minimal / non electronic arsenal:

  1. Pulsar watches: while Pulsar was first to introduce digital  LED watches, the ones I have are ‘automatic’ – fully mechanical taking kinetic energy of my hand to tick. No expensive at all. It was little bit hard to resist urge to buy smart watches (and all rationalization for the workouts) however ‘doesn’t need batteries’ (instead of batteries included) is so appealing !
  2.  Zenit 11: I found accidentally never used, virgin  analogue camera Zenit 11 (from ’80)  and bought it for few CZKs. It uses selenium cells for exposure measure, so no need for batteries at all.  This will be fun to try ! I used to have Zenit 12 so this is come back ! For note taking / documentary photos I will continue to use  digital camera. Zenit 11 will be my tool for mindfulness, patience, slow down -. Really excited with this piece. It smells  like just assembled in the KMZ factory and the sound of the closure is so pleasing… isn’t the name cool ? literally  ZEN  IT !
  3. Nokia 8110 4G : this is not smartphone, but replica of original Nokia 8110 used in Matrix, yet this supports LTE and hotspot, (except calls and SMS)-  all I need to use. KaiOS and cheap  buttons  slows me down to think before I call or react. This phone-modem will be used on the road as hotspot to power up my connectivity needs on other devices / computers on demand. So no more compulsive checks of emails, updates, social and other network etc.
  4. Bullet Journal : simple analogue system to track my progress and notes on various facets of my life, ideas, notes, hand written. Colored by pastel pencil with eraser.
  5. Solarex SSR 97 :  Solar only powered scientific calculator (from ’80)
  6. Coffee mill:  for my very own coffee ‘hand made’.
  7. Hourglass: do not confuse with waiting Windows hourglass, this ones are for deep work, focus, concentration, no interruption work.
  8. Rolling ruler: nice analog tool for parallels – many of them…

 

Another aspect to compensate “hyperdigitalisation” is workouts – I could finish 90 days challenge by Mark Lauren and can continue with his “You are Your Own Gym” workouts.

workout

Hybrid vs Native

It has been a while since my iOS native development. Just came across this report on the subject of native vs hybrid : Native vs Hybrid . Interestingly enough I have expected clear recommendation for hybrid as today devices are more capable of handling rich HTML/JavaScript content and iOS native bridges enable nice integrations with these two worlds.

Declarative vs. imperative mismatch

Notes from Jenkov.com : http://tutorials.jenkov.com/angularjs/critique.html about AngularJS Declarative vs Imperative. Couldn’t say this better…the art is to find right balance. Neither XAML , nor AngularJS found it yet (too declarative):

Quoted from the source:

Using declarative HTML templates with a bit of data binding injected is not a new idea. It has been tried before in JSP (JavaServer Pages). Here is an example:

<span><%=myObject.getMyProperty()%></span>

In AngularJS it would look like this:

<span>{{myObject.getMyProperty()}}</span>

The Declarative / Imperative Paradigm Mismatch

Declarative languages (such as HTML and XML) are good a modeling state such as documents, or the overall composition of a GUI. Imperative languages (such as JavaScript, Java, C etc.) are good a modeling operations. The syntaxes of both declarative and imperative languages were designed to support their specific purposes. Therefore, when you try to use a declarative language to mimic imperative mechanisms it may work for simple cases, but as the cases get more advanced the code tend to become clumsy

The same is true the other way around. Using an imperative language will often also get clumsy. Anyone who has tried writing an HTML document using JavaScript’s document.write() function, or wired up a Java Swing GUI using Java, or an SWT GUI for that matter, knows how clumsy this code can get.

It is easy to think that the declarative / imperative mismatch can be avoided with a programming language that is designed to handle both paradigms. But the problem goes deeper than the language syntax.

It is not the syntax of a programming language that decides if the language is declarative or imperative. It is the semantic meaning of what the language describes that decides between declarative and imperative. You could invent a more Java-like syntax to describe HTML elements. Or a more HTML-like syntax to describe Java instructions. But such syntaxes would not change the fact that one language describes state (HTML documents) and the other language describe commands (operations). Thus, a Java-like syntax for describing HTML documents would still be declarative, and a more HTML-like syntax for describing Java-operations would still be imperative.

 

WebGL polyline tessellation with MapBox-GL-JS

update 09/20015 : test of tesspathy.js library here . Other sources to look:

  1.  http://mattdesl.svbtle.com/drawing-lines-is-hard
  2.  https://github.com/mattdesl/extrude-polyline
  3. https://forum.libcinder.org/topic/smooth-thick-lines-using-geometry-shader

*** original post ***

This post attempted to use pixi.js tessellation of the polyline, this time let’s look on how mapbox-gl-js can do this. In short much more better than pixi.js.

it took slightly more time to get the right routines from mapbox-gl-js and find-out where the tessellation is calculated and drawn. It is actually on two places – in LinBucket.js  and in line shader. FireFox shader editor helped a lot to simplify and extract needed calculations and bring it into the JavaScript (for simplification, note however that shader based approach is the right one as you can influence dynamically thickness of lines, while having precaluclated mesh means each time you need to change thickness of line you have to recalculate whol e mesh and update buffers )

 

// — module require mockups so we can use orig files unmodified
 module = {};
 reqMap = {
‘./elementgroups.js’: ‘ElementGroups’,
‘./buffer.js’ : ‘Buffer’
};
require = function (jsFile) { return eval(reqMap[jsFile]); };

 

   &lt;!-- all mapbox dependency for tesselation of the polyline --&gt;
 &lt;script src=&quot;http://www.sumbera.com/gist/js/mapbox/pointGeometry.js&quot;&gt;&lt;/script&gt;
    &lt;script src=&quot;http://www.sumbera.com/gist/js/mapbox/buffer.js&quot;&gt;&lt;/script&gt;
    &lt;script src=&quot;http://www.sumbera.com/gist/js/mapbox/linevertexbuffer.js&quot;&gt;&lt;/script&gt;
    &lt;script src=&quot;http://www.sumbera.com/gist/js/mapbox/lineelementbuffer.js&quot;&gt;&lt;/script&gt;
    &lt;script src=&quot;http://www.sumbera.com/gist/js/mapbox/elementgroups.js&quot;&gt;&lt;/script&gt;
    &lt;script src=&quot;http://www.sumbera.com/gist/js/mapbox/linebucket.js&quot;&gt;&lt;/script&gt;
    &lt;script src=&quot;http://www.sumbera.com/gist/data/route.js&quot; charset=&quot;utf-8&quot;&gt;&lt;/script&gt;
 // -- we don't use these buffers, override them later, just set them for addLine func
 var bucket = new LineBucket({}, {
 lineVertex: (LineVertexBuffer.prototype.defaultLength = 16, new LineVertexBuffer()),
 lineElement: (LineElementBuffer.prototype.defaultLength = 16, new LineElementBuffer())
 });

var u_linewidth = { x: 0.00015 };
// override .add to get calculated points
LineVertexBuffer.prototype.add = function (point, extrude, tx, ty, linesofar) {
    point.x = point.x + (u_linewidth.x * LineVertexBuffer.extrudeScale * extrude.x * 0.015873);
    point.y = point.y + (u_linewidth.x * LineVertexBuffer.extrudeScale * extrude.y * 0.015873);
    verts.push( point.x, point.y);
    return this.index;
};

// — pass vertexes into the addLine func that will calculate points
bucket.addLine(rawVerts,“miter”,“butt”,2,1);

prototype  code posted here

 

TypeScript: Bringing Sanity to JavaScript

Great summary of the TypeScript features…

Didactic Code

TypeScriptAs much as I’d prefer to be working in F#, I’ve found myself doing quite a bit of JavaScript lately. I’m hardly a JavaScript expert but I like to think my skills areabove average(although that could merely be wishful thinking).I won’t deny that JavaScript has its problems but I think that it has traditionally been maligned by things that aren’t necessarily the language’s fault; for instance, DOM inconsistencies are hardly under JavaScript’scontrol. Generally speaking, I really do enjoy working with JavaScript. That said, there are things such as prototypal inheritance that I always struggle with and I know I’m definitely not alone. That’s why I decided to take a look at TypeScript now that it has finally earned a 1.0 moniker.

By introducingarrow function expressions, static typing, and class/interface based object-oriented programming, TypeScript bringssanity to JavaScript’s more troublesome areas and gently guides us to writing manageable code using familiar paradigms…

View original post 4,109 more words