231 Matching Annotations
  1. Jun 2019
    1. Entities are the applications, services, and files in the ARGON worldview

      smalltalk objects

    1. In 1947, a high-flying moth bumped into Harvard’s Mark II Aiken Relay Calculator, was removed by computer operator William Burke, and then taped to the computer log - popularizing the existing term “debugging.”Figure 4: debugging
  2. May 2019
    1. Go Programming Language publicly in 2009 they were also looking to solve certain challenges of the existing Computer languages. Of the many features that it demonstrated (we will get to those soon enough) it was also helpful in addressing the strange dilemma of hardware and software that was emerging.

      Golang is a modern computing language, designed especially for modern computing needs.

    1. we process millions of transactions per day here and we really need someone with more relevant experience who can handle these things without ramping up
    1. I want to stop putting comments in my code. I want it to be first-class for my code to be in the left pane and my comments to be in the right pane, always binded together with anchors but always separate so my comments don't have to adhere to the limitations of the code's text area.

      emacs--annotate.el

  3. Apr 2019
  4. Mar 2019
  5. Feb 2019
    1. :ok

      nice, return value: keyword!

    2. (fn [system] (throw (ex-info "initializer not set, did you call `set-init`?" {}))))

      interesting pattern, default function throws kind of like abstract base classes methods in python

  6. Jan 2019
    1. If one object is part of another object, then we use a diamond at the start of the arrow (next to the containing object), and a normal arrow at the end.

      Another way of thinking of this is, if the original owner (source) object and the owned (target) object share the same life cycle -- that is, the owned exists only when the owner does -- we say that the owner aggregates owned object(s). They share a whole-part relationship.

      What I did like very much about the video, was when the instructor pointed out that there's a small fallacy: aggregation, in OOD, does not really imply that owned object(s) must be a list.

    1. Grid devices can be nested or layered along with other devices and your plug-ins,

      Thanks to training for Cycling ’74 Max, had a kind of micro-epiphany about encapsulation, a year or so ago. Nesting devices in one another sounds like a convenience but there’s a rather deep effect on workflow when you start arranging things in this way: you don’t have to worry about the internals of a box/patcher/module/device if you really know what you can expect out of it. Though some may take this for granted (after all, other modular systems have had it for quite a while), there’s something profound about getting modules that can include other modules. Especially when some of these are third-party plugins.

    1. after the terminal operation of the stream pipeline commences.

      Above is because of the nature of Streams in general: they are lazily executed (or put another way, execution is delayed until the latest convenient method call).

  7. Dec 2018
    1. Full disclosure: I’m a co-maintainer of clj-time and I’m pretty vocal about encouraging people not to use clj-time when starting a new project: use Java Time instead. Conversion from an existing, clj-time-heavy project is another matter tho’, unfortunately.

      sean cornfield co-mainainter of clj-time use Java.Time

  8. Nov 2018
    1. Meditation can not only provide a welcome counterweight to this work with abstractions, it also cultives 10 qualities of character (Pali: paramis) that are useful during the practice of programming.

      Generosity Morality Renunciation Understanding Effort Patience/tolerance Truthfulness Loving-kindness Equanimity

    1. One thing Component taught me was to think of the entire system like an Object. Specifically, there is state that needs to be managed. So I suggest you think about -main as initializing your system state. Your system needs an http client, so initialize it before you do anything else

      software design state on the outside, before anything else lessions from Component

    2. For the sweet spot you're looking for, I suggest being clear about if you're designing or developing. If you're designing and at the REPL, force yourself to step away with pen and paper after you've gotten some fast feedback.

      designing vs developing!

    1. Re-open libraries for exploration I use in-ns to jump into library namespaces and re-define their vars. I insert bits of println statements to help understand how data flows through a library. These monkey-patches only exist in the running REPL. I usually put them inside a comment form. On a REPL restart, the library is back at its pristine state. In this example below, I re-open clj-http.headers to add tracing before the header transformation logic: [source] ;; set us up for re-opening libraries (require 'clj-http.headers) (in-ns 'clj-http.headers) (defn- header-map-request [req] (let [req-headers (:headers req)] (if req-headers (do (println "HEADERS: " req-headers) ;; <-- this is my added print (-> req (assoc :headers (into (header-map) req-headers) :use-header-maps-in-response? true))) req))) ;; Go back to to the user namespace to test the change (in-ns 'user) (require '[clj-http.client :as http]) (http/get "http://www.example.com") ;; This is printed in the REPL: ;; HEADERS: {accept-encoding gzip, deflate} An astute observer will notice this workflow is no different from the regular clojure workflow. Clojure gets out of your way and allows you to shape & experiment in the code in the REPL. You can use this technique to explore clojure.core too!

      explore library code in the repl in-ns and the redefinition

    2. Unmap namespaces during experimentation I use ns-unmap and ns-unalias to remove definitions from my namespace. These are the complementary functions of require and def. While exploring, you namespace will accrue failed experiments, especially around naming. Instead of using a giant hammer [tools.namespace], you can opt for finer-grained tools like these. Example: (require '[clojure.string :as thing]) (ns-unalias *ns* 'thing) ; *ns* refers to the current namespace

      cleaning up the namespace fro repl experimentation

    1. That is using a specific tool for a specific use case. You don’t actually have a table view of your data. Once it’s in a table, man, you’re good. That is the modeling. A sequel database table, you have this amazing high-level language for doing all sorts of cool operations with it.To turn this into some class hierarchy, it’s almost criminal. There, I said it. It’s like you’re throwing away the power that you have.

      about a situation when you sometime want an is-a relationship but in most cases just have it as loosely structured (table-like) data format

  9. Oct 2018
    1. A lot of this would be a non issue if we had end user programming. The problem today is that 'configurability' is itself something the programmer needs to implement

      acme example rob pike apparently had an elaborate answer as to why he wouldn't allow to change the colorschme

    2. Configuration knowledge is anti-knowledge -- learning how to conform to the inessential quirks of a system somebody else made up

      good take on configuration

    3. 1 reply 1 retweet 5 likes Reply 1 Retweet 1 Retweeted 1 Like 5 Liked 5 Direct message Omar Rizwan‏ @rsnous Feb 16 More Copy link to Tweet Embed Tweet Mute @rsnous Unmute @rsnous Block @rsnous Unblock @rsnous Report Tweet Add to other Moment Add to new Moment Replying to @rsnous @disquiet07 files are a weak lowest-common-denominator interface between programs in different languages (C, Python, Ruby, Swift, VB, bash, etc) in ecosystems with one language (iOS, JS, Lisp, Smalltalk), you often don't see files: you just persist the rich native structures of the language 4 replies 2 retweets 16 likes Reply 4 Retweet 2 Retweeted 2 Like 16 Liked 16 Direct message Gordon Brander‏ @gordonbrander 3h3 hours ago More Copy link to Tweet Embed Tweet Mute @gordonbrander Unmute @gordonbrander Block @gordonbrander Unblock @gordonbrander Report Tweet Add to other Moment Add to new Moment Replying to @rsnous @disquiet07 OTOH — lowest common denominator interfaces allow for emergent behavior. They focus all the constraints in one place, leaving the rest of the system definition open-ended. Like defining the LEGO dot, but not what shape pieces may take. 1 reply 0 retweets 3 likes Reply 1 Retweet Retweeted Like 3 Liked 3 Direct message Omar Rizwan‏ @rsnous 2h2 hours ago More Copy link to Tweet Embed Tweet Mute @rsnous Unmute @rsnous Block @rsnous Unblock @rsnous Report Tweet Add to other Moment Add to new Moment Replying to @gordonbrander @disquiet07 With files, imo the lack of structure 1. forces duplication of functions at the app level (de/serialization, cross-links, …) and 2. prevents coordination for higher-level behavior #1 here seems different from LEGO, but I can't quite articulate it in terms of your analogy 1 reply 0 retweets 2 likes Reply 1 Retweet Retweeted Like 2 Liked 2 Direct message Gordon Brander‏ @gordonbrander 2h2 hours ago Follow Follow @gordonbrander Following Following @gordonbrander Unfollow Unfollow @gordonbrander Blocked Blocked @gordonbrander Unblock Unblock @gordonbrander Pending Pending follow request from @gordonbrander Cancel Cancel your follow request to @gordonbrander More Copy link to Tweet Embed Tweet Mute @gordonbrander Unmute @gordonbrander Mute this conversation Unmute this conversation Block @gordonbrander Unblock @gordonbrander Report Tweet Add to other Moment Add to new Moment Replying to @rsnous @disquiet07 I agree. Low-level interop has a high floor, high ceiling. Higher-level interop (like Smalltalk) has lower floors, because deeper system integration. However, that deeper integration often means you end up more entangled with the system’s strengths and weaknesses.
    1. Rob Pike has described Plan 9 as "an argument" for simplicity and clarity, while others have described it as "UNIX, only moreso."

      idea of a system as an argument pointed out by: https://twitter.com/rsnous/status/1054631468142493696

    1. In computer science and logic, a dependent type is a type whose definition depends on a value. A "pair of integers" is a type. A "pair of integers where the second is greater than the first" is a dependent type because of the dependence on the value.

      this is not the most impressive defitnition but it does the job ;) it's more like "relational types" where type definitions include relations between potential values

    2. On the flip side, it can go further than mere types, including emulating dependent types and programming-by-contract.

      spec though it's used at runtime (not compile time)

      • hence: not a replacement for types as such BUT
      • enables dependent types
      • programming by contract
    1. Perhaps part of the confusion - and you say this in a different way in your little memo - is that the C/C++ folks see OO as a liberation from a world that has nothing resembling a first-class functions, while Lisp folks see OO as a prison since it limits their use of functions/objects to the style of (9.). In that case, the only way OO can be defended is in the same manner as any other game or discipline -- by arguing that by giving something up (e.g. the freedom to throw eggs at your neighbor's house) you gain something that you want (assurance that your neighbor won't put you in jail).

      [9] "Sum-of-product-of-function pattern - objects are (in effect) restricted to be functions that take as first argument a distinguished method key argument that is drawn from a finite set of simple names."

    2. Sum-of-product-of-function pattern - objects are (in effect) restricted to be functions that take as first argument a distinguished method key argument that is drawn from a finite set of simple names.

      fwiu: the "finte set of simple names" are all the objects defined in the codebase e.g. in java there are no functions as such just methods attached to classes i.e. "their key argument"

    3. All you can do is send a message (AYCDISAM) = Actors model - there is no direct manipulation of objects, only communication with (or invocation of) them. The presence of fields in Java violates this.

      from what I understand in Java... there are some variables on classes (class instances) that are only acessible through methods and for those the "only send message" paradigm holds but there are also fields which are like attributes in python which you can change directly

    4. Parametric polymorphism - functions and data structures that parameterize over arbitrary values (e.g. list of anything). ML and Lisp both have this. Java doesn't quite because of its non-Object types.

      generics so you've got a "template" collection e.g. Collectoin<animal> and you parametrise it with the Animal type in this example how is that broken by "non-Object types" in java</animal>

    5. Ad hoc polymorphism - functions and data structures with parameters that can take on values of many different types.

      does he mean that list in python is polymorphic because it can be list of integers or string or ... ?

    6. Encapsulation - the ability to syntactically hide the implementation of a type. E.g. in C or Pascal you always know whether something is a struct or an array, but in CLU and Java you can hide the difference.

      is this because:

      • interfaces--contextually identical (because satisfy common set of behaviours)?
      • or being wrapped in objects (thus blurring the difference)?
    1. Following Christopher Strachey,[2] parametric polymorphism may be contrasted with ad hoc polymorphism, in which a single polymorphic function can have a number of distinct and potentially heterogeneous implementations depending on the type of argument(s) to which it is applied. Thus, ad hoc polymorphism can generally only support a limited number of such distinct types, since a separate implementation has to be provided for each type.

      kind of like clojure multimethods but those can dispatch on arbitary function hence arbitrary "property"

    2. In programming languages and type theory, parametric polymorphism is a way to make a language more expressive, while still maintaining full static type-safety. Using parametric polymorphism, a function or a data type can be written generically so that it can handle values identically without depending on their type.[1] Such functions and data types are called generic functions and generic datatypes respectively and form the basis of generic programming.

      so essentially this is just a way to escape the contrains of types--overspecifying the type of argument for e.g. append function

      I guess the behaviour implement cannot really implement on the type of value

    1. Best practices will not automatically spare you from development pain. A unique product will have unique problems, and best practices are not a substitute for careful thought.

      but you can do "contextual/local best practices" e.g. don't use abrreviations in function names other than: <team-wide-whitelist-of-abbr></team-wide-whitelist-of-abbr>

    1. One is the linked list of lines you mention. I believe this is intended to solve a display problem that TECO (the original language in which Emacs was implemented) had solved differently using the "gap" data structure. The fundamental issue was that if you have a buffer represented as a single block of contiguous text, then insertion on a character-by-character basis can be O(n2), each time you insert a character, you have to copy the entire subsequent buffer over one space.

      implementation, performence of text entry

    2. Lisp macros were also useful for the definition of new control structures, as well as new data structures. In ZWEI, we created a new iterative control structure called charmap, which iterates over characters in an interval. Intervals are stored as doubly-linked lists of arrays, and the starting point might be in the middle of one array and the ending point might be in the middle of another array. The code to perform this iteration was not trivial, and someone reading it might easily not understand the function it was performing, even though that function was the conceptually simple one of iterating over characters. So we created a macro called charmap that expands into the double-loop code to iterate over the characters. It is simple and obvious, and is used in many places, greatly reducing the size of the code and making the functionality obvious at a glance.

      use of macros implementing data structures making things more readable!

    3. It became policy to avoid abbreviations in most cases. In ZWEI, we made a list of several words that were used extremely often, and established 'official' abbreviations for them, and always used only those abbreviations. ... Words not on this list were always spelled out in full.

      abbreviations whitelist - good programming practice!

    4. Some paragraphs are devoted to what must have been a novel concept at the time for such a system: that the Lisp Machine was a personal system, not time-shared, and this gave rise to features not viable on time-sharing systems, due to the fact that the user was not contending with other users for resources.

      personal computers as novel concept (vs time sharing) and what it enables

    1. Wehler et al38 reported that homeless and low-income mothers who experienced sexual assault in childhood were over 4 times more likely to have household level food insecurity than women who had not been abused

      Esto es un ejemplo de "Programming" por eventos en la niñez que pueden tener implicaciones en el curso de la vida. Es como un tipo de predisposición, ya que una mujer que ha sido abusada sexualmente está cuatro veces más propensa a tener un hogar con inseguridad alimentaria.

  10. Sep 2018
    1. Use React for ephemeral state that doesn't matter to the app globally and doesn't mutate in complex ways. For example, a toggle in some UI element, a form input state. Use Redux for state that matters globally or is mutated in complex ways. For example, cached users, or a post draft. Sometimes you'll want to move from Redux state to React state (when storing something in Redux gets awkward) or the other way around (when more components need to have access to some state that used to be local).
  11. Aug 2018
  12. Jun 2018
    1. Raccomandazione 3.6g - Definire un modello di governance del dato e progettare automatismi organizzativi e tecnologici

      ogni applicativo gestionale in uso nelle Pubbliche Amministrazioni centrali e locali DEVE(!) fare uso di [API (Application Programming Interface)] (https://pianotriennale-ict.readthedocs.io/it/latest/search.html?check_keywords=yes&area=default&q=api) al fine di pubblicare, in modalità automatica, dati tematici aggiornati in tempo reale. Senza l'uso di API pubbliche (e documentate) non ci sarà mai un sistema di dati pubblici in formato aperto su cui poter fare riferimento per creare qualsiasi tipo di riuso costante ed utile alla società e per la nascita di nuove forme di economia. Senza API pubbliche continueranno ad esserci soltanto isolati esercizi di stile di qualche rara Pubblica Amministrazione (nel contesto nazionale) sensibile alla pubblicazione dei dati, soltanto perchè fortunatamente vede al suo interno del personale dirigente/dipendente sensibile culturalmente all'obbligo (non sanzionato in caso di non rispetto) della pubblicazione dei dati.

      Oggi (2018) l'uso delle API pubbliche nei software delle PA non va raccomandato, va imposto! Diversamente si continua a giocherellare come si fa per ora. Ma niente dati di qualità e su cui fare riferimento senza API pubbliche nei software della PA!

  13. May 2018
    1. This behavior also argues for following the convention of placing an opening curly brace at the end of a line in JavaScript, rather than on the beginning of a new line. As shown here, this becomes more than just a stylistic preference in JavaScript.

      I was on the righteous side all those years! Yey!

    1. hi there please check on the Recent Updated SAS Training and Tutorial Course which can explain about the SAS and its integration with the R as well so please go through the Link:-

      https://www.youtube.com/watch?v=IOxaKq4lB-0

  14. Apr 2018
    1. (== 10)

      This confused me. I'm relatively new to Haskell and did not know about sectioning. After learning that detail, this makes sense as a (right) partial application of the (==) function.

  15. Mar 2018
    1. Lucius Gregory Meredith, Mike Stay, and Sophia Drossopoulou. Policy as types. CoRR, 2013. URL: http://arxiv.org/abs/1307.7766.

      I think I have my head around this one now.

    1. a mutator method is a method used to control changes to a variable. They are also widely known as setter methods

      For example, a method definition in Java would be:

      class MyClassDef {
      
          public void setProperty(String propertyVal) { .. }
      
      }
      

      For above, setProperty(..) method is the mutator

    1. In a let expression, the initial values are computed before any of the variables become bound.
      • let binding 先在当前环境中计算所有 init 表达式的值, 再 bind varible, 最后在扩展的环境中计算 expression

      • let* 按顺序依次计算 init 并进行 binding

      • letrec 则先 binding 后再计算 init 允许递归定义

  16. Jan 2018
    1. There is only one codebase per app, but there will be many deploys of the app

      Typically Terraform violates the spirit of this principle. Though each deploy may be defined (typically as an environment) in the same repo, the codebase is different. We work around this making heavy use of modules to limit divergence between deploys.

  17. Dec 2017
    1. Most of the recent advances in AI depend on deep learning, which is the use of backpropagation to train neural nets with multiple layers ("deep" neural nets).

      Neural nets consist of layers of nodes, with edges from each node to the nodes in the next layer. The first and last layers are input and output. The output layer might only have two nodes, representing true or false. Each node holds a value representing how excited it is. Each edge has a value representing strength of connection, which determines how much of the excitement passes through.

      The edges in an untrained neural net start with random values. The training data consists of a series of samples that are already labeled. If the output is wrong, the edges are adjusted according to how much they contributed to the error. It's called backpropagation because it starts with the output nodes and works toward the input nodes.

      Deep neural nets can be effective, but only for single specific tasks. And they need huge sets of training data. They can also be tricked rather easily. Worse, someone who has access to the net can discover ways of adding noise to images that will make the net "see" things that obviously aren't there.

    1. A mental map (or cognitive map) is our mental representation of a place. It includes features we consider important, and is likely to exclude features we consider unimportant.

      (Urban planner Kevin Lynch, early 1960s)<br> Elements of mental maps

      • paths
      • edges - boundaries and endings
      • nodes - focal points like squares and junctions
      • districts
      • landmarks

      Modern maps could use augmented and virtual reality to help clarify those elements, making a place easier to navigate and use. But they can also add useless noise that makes the place seem more confusing than it actually is.

  18. Nov 2017
    1. officially-approvedprogramminglanguagesatGoogle:C++,Java,Python,Go,orJavaScript.Minimizingthenumberofdifferentprogramminglanguagesusedreducesobstaclestocodereuse and programmer collaboration.

      Googleの承認済みプログラム言語

  19. Oct 2017
    1. Why is all the focus on teaching lay people how to code, and not teaching computer scientists and people who work in tech companies to center empathy and humanity in their work?

      . . .

      I think there should be an element of infusing discussions of ethics, humanity and social consequences into computer science curricula, and I believe that even human-centered design does not go far enough; I suggest that designers of tech consider more “empathetic and participatory design” where there is some degree of involving people who are not in the tech company as autonomous persons in product design decisions, and not just using them as research/testing subjects.

  20. Sep 2017
    1. but the true technology of Java is not in the language, but the virtual machine itself. The JVM as it stands today, is a fast, abstract machine that you can plug any languages into, and is able to operate at speeds comparable to natively compiled binaries.

      This is something really neat to ponder at... Thank you for your insight!

    1. echo "deb https://dl.bintray.com/sbt/debian /" | sudo tee -a /etc/apt/sources.list.d/sbt.list sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 2EE0EA64E40A89B84B2DF73499E82A75642AC823 sudo apt-get update sudo apt-get install sbt
    1. hm. lots of moving parts. Doesn't give the minimal / orthogonal feel of kernel monte + safeScope. No Near / Far refs?

      (describe any?) goes to stdout - ambient!

  21. Aug 2017
    1. Since Clojure uses the Java calling conventions, it cannot, and does not, make the same tail call optimization guarantees. Instead, it provides the recur special operator, which does constant-space recursive looping by rebinding and jumping to the nearest enclosing loop or function frame. While not as general as tail-call-optimization, it allows most of the same elegant constructs, and offers the advantage of checking that calls to recur can only happen in a tail position.

      Clojure's answer to the JVM's lack to tail call optimization

    1. “Programming is like thinking about thinking. And debugging is a close approximation of learning about learning.” When you program, you translate your thoughts into executable form. Debugging your program is close to debugging your thoughts.
    2. The thrill of programming, for me, is found more in the exploration of ideas than in the joy of controlling machines.

      This is something that I can relate to. I tend to program as I learn a subject that I eventually want to write real programs for, as an aide to understanding. It helps me grok how things work in the new domain. It also helps me retain the new information.

  22. Jul 2017
    1. there are two different measurements for the length of a foot in the United States: the International Foot (also commonly called the foot) and the U.S. Survey Foot. The International Foot (which we were all taught in school) is defined as 0.3048 meters, whereas the U.S. Survey Foot is defined as 0.3048006096 meters. The difference of the two equates to 2 parts per million.

      For example, in a measurement of 10,000 feet, the difference would be 0.02 feet (just less than one-quarter of an inch). In a measurement of 1 million feet, the difference is 2 feet.

  23. Jun 2017
    1. Emergent AI does not suggest that the computer be given rules to follow but tries to set up a system of independent elements within a computer from whose interactions intelligence is expected to emerge. Its sustaining images are drawn, not from the logical, but from the biological. Families of neuron-like entities, societies of anthropomorphized subminds and sub-subminds, are in a simultaneous interaction whose goal is the generation of a fragment of mind. We noted that these models are sometimes theorized in notions of "mind as society," where negotiational processes are placed at the heart of all thinking. Those who espouse and support such models are more inclined to find bricolage acceptable than are classical Piagetians. What concerns us here is not which of these trends in AI is "correct," just as we aren't advocating a choice between the use of icons and the use of textual instructions in computer operating systems. What does concern us is that the new trends -- icons, object-oriented programming, actor languages, society of mind, emergent AI -- all create an intellectual climate in the computational world that undermines the idea that formal methods are the only methods.
    2. As it happens, the Macintosh's iconic style may be winning this argument. The designers of computer interfaces might interpret this as final proof of the technical superiority of icons. A psychologist might read it as putting in question the hard/soft split. Perhaps everyone is really "soft" after all, and "hard" is a construct that is dropped when it is not needed for acceptability or prestige or functionality. Others might simply say that icons are "easier." All of the above may be in part true. But from our perspective what is important is that the iconic victories are part of a larger cultural shift towards an acceptance of concrete, relational ways of thinking.
    3. Music students live in a culture that, over time, has slowly grown a language and models for close relationships with music machines. The harpsichord, like the visual artists' pencils, brushes, and paints, is "just a tool." And yet we understand that artists' encounters with these can (and indeed, will most probably) be close, sensuous, and relational. And that artists will develop highly personal styles of working with them.
    4. The computer presence has provoked a "romantic reaction" in our culture.24 As people take computers seriously as simulated mind, many are in conflict with the mechanistic image that is reflected back to them in the mirror of the machine. They define the specificity of people in terms of what computers cannot do. Simulated thinking may be thinking, but simulated love is never love. Women express this sentiment with particular urgency. We believe this is because a conflict fuels their conviction. A comfortable style of thinking would have them get close to the objects of thought. The computer offers them objects of thought. But the closer they get to this machine, the more anxious they feel. The more they become involved with the computer, the more they insist that it is only a neutral tool. A way out of the impasse would require profound change in the culture that surrounds the computer tool. If the computer is a tool, and of course it is, is it more like a hammer or more like a harpsichord?
    5. The development of a new computer culture would require more than technological progress and more than environments where there is permission to work with highly personal approaches. It would require a new and softer construction of the technological, with a new set of intellectual and emotional values more like those we apply to harpsichords than hammers.25 If computers are really the tools we use to write, to design, to play with ideas and shapes and images, they should not be addressed with the language of desktop calculators. Moving out of the impasse also would require the reconstruction of our cultural assumptions about hard logic as the "law" of thought. Addressing this question brings us full circle to where we began, with the assertion that epistemological pluralism is a necessary condition for a more inclusive computer culture.
    6. Our central thesis is that equal access to even the most basic elements of computation requires an epistemological pluralism, accepting the validity of multiple ways of knowing and thinking.
  24. May 2017
    1. "who's the target of the assignment (LHS)" and "who's the source of the assignment (RHS)".

      LHS is looking for the target of that assignment whiel RHS is looking for the source!

  25. Apr 2017
    1. Dave Winer points out that interoperability of software is important. Don't shun an existing standard just because you think your way is better. If you hate using some standard technology, find or write a module to convert between the standard and your preferred format.

    1. 결국 메타언어에 존재하는 정보를 프로그래밍 언어에 합리적으로 추가하면, 더 유용하게 사용할 수 있다.

  26. Mar 2017
    1. Suggestion for a programming language in which commands are displayed as comic strip panels, with each one showing the output up to that point.

      https://twitter.com/jasonbrennan

  27. awjin.github.io awjin.github.io
    1. Dynamic Programming

      Here's another article, with a different point-of-view on this subject.

    1. Check out

      Some other problems can be found in the quoted works section, for this paper/web page. For example, have a look here.

    2. In this solution, we used memoization to recursively calculate the solutions for subproblems which we then used to calculate the solutions to larger problems. Alternatively, tabulation could have been used to build up solutions from the bottom up.

      So, from the whole thing I take it that the problem has actually two parts: i.) a pre-processing part in which all paths have been explored (via memoization), and, ii). discover the optimal path to take, given the memoization table.

  28. Jan 2017
  29. Dec 2016
  30. Nov 2016
    1. A knack for programming can pull someone out of poverty. But first they need a computer. And it helps much more if they are introduced to people in the profession to mentor them and help them find a job.

  31. Oct 2016
  32. Sep 2016
  33. Jul 2016
    1. Pages 7-8

      Rockwell and Sinclair talk here about developing an “agile hermeneutics” by which they mean an approach to fast/extreme writing. An example of this is that they tried to write a short essay in one day from the initial research but they also do things such as working in pairs with one person typing and the others talking things through.

    1. Neil Fraser says Vietnam is doing well with computer science education.

      "If grade 5 students in Vietnam are performing at least on par with their grade 11 peers in the USA, what does grade 11 in Vietnam look like? I walked into a high school CS class, again without any advance notice. The class was working on the assignment below (partially translated by their teacher for my benefit afterwards). Given a data file describing a maze with diagonal walls, count the number of enclosed areas, and measure the size of the largest one."

    1. #registration

      same as CSS, # refers to element ID

    2. input

      which child element do you want to manipulate, separated with a space

    3. [name=confirmation]

      like an associative array, looking for where the attribute name = confirmation

    1. .

      [dot] operator to access elements like structs in C.

    2. script src

      Point to an external JavaScript file: http://www.w3schools.com/tags/att_script_src.asp

    3. onsubmit attribute within our script, which we know is a valid event listener for a form element.

      from the list of event listeners