Borgmarks - Merlin Corey at Github dot I/O

In the future we will want to have to category and potentially even subcategory pages.

This will mean either compiling those pages from the master list, or compiling the master list from those pages. Compiling the master list from the categories and subcategories seems most appropriate.

Originally, Borgmarks was a single index.org file with some example elisp code.

Well written post linked to from this discussion on reddit and elsewhere.

(setq org-capture-templates
  '(
    ;; many more capture templates
    ("b" "Bookmark" entry (file+headline "~/share/all/org-mode/notes.org" "Bookmarks") "* %?\n:PROPERTIES:\n:CREATED: %U\n:END:\n\n" :empty-lines 1)
    ;; many more capture templates
   )
)

The documentation and code quality is all good.

The implementation choices leave some things to be desired. The Queue and Stack implementations are Linked Lists instead of array backed, the hash table is closed instead of (the only barely more complicated) open Robin hood hash table scheme, the union-find/disjoint-set implementation doesn't have path compression or rank unions.

Overall very good, but it could be Great (tm) with just a little bit of work.

> I thought array-based queues resulted in O(n) queue/dequeue.

Not necessarily. A circular buffer[1] can be used as a queue with O(1) queue/dequeue. C++ implementations (gcc?), IIRC, uses an interesting array-of-arrays approach; it also has O(1) queue/dequeue. I'm not sure why the array-of-arrays approach is better than a circular buffer, though.

Array based designs can result is less allocations, and maybe less overhead. For example, if you have a circular buffer with space for 16 items, it only needs to allocate space if you need more room, whereas a linked list queue would allocate for each and every item placed into it. Linked lists also require space for the pointer to the next link, for each link in the list. (And, if you keep them, back pointers, though these aren't necessary for just a queue.) Arrays might have some unused slack space, however.

[1]: https://en.wikipedia.org/wiki/Circular_buffer

Resizing a fully contiguous circle buffer would cause a copy every element as well forcing you to make a single contiguous memory section. Array of arrays just needs to resize the top level array.

But the copy only has to move n items, but was constructed with m items, where n < m (and usually n << m). Where n is the max size of the queue and m is the total number of items that will ever be enqueued.

On the other hand, an array of arrays (no recursion) doesn’t change the big-O complexity cost, just the constant multiplier. That should definitely improve performance of the uncommon operation (the copy), but hypothetically might slow down the actual queuing operations (and drastically reduce throughout)

But maybe you meant the array of arrays to be recursive? That seems like it would alter the big-O (from n+m to log(n)+m). But typically m>>n, so the net result is the same.

Elementary

Cannot be broken down into smaller pieces

Knightship

Glider that moves 2 horizontal and 1 vertical unit in its lifecycle

x = 31, y = 79, rule = B3/S23
4b2o$4bo2bo$4bo3bo$6b3o$2b2o6b4o$2bob2o4b4o$bo4bo6b3o$2b4o4b2o3bo$o9b
2o$bo3bo$6b3o2b2o2bo$2b2o7bo4bo$13bob2o$10b2o6bo$11b2ob3obo$10b2o3bo2b
o$10bobo2b2o$10bo2bobobo$10b3o6bo$11bobobo3bo$14b2obobo$11bo6b3o2$11bo
9bo$11bo3bo6bo$12bo5b5o$12b3o$16b2o$13b3o2bo$11bob3obo$10bo3bo2bo$11bo
4b2ob3o$13b4obo4b2o$13bob4o4b2o$19bo$20bo2b2o$20b2o$21b5o$25b2o$19b3o
6bo$20bobo3bobo$19bo3bo3bo$19bo3b2o$18bo6bob3o$19b2o3bo3b2o$20b4o2bo2b
o$22b2o3bo$21bo$21b2obo$20bo$19b5o$19bo4bo$18b3ob3o$18bob5o$18bo$20bo$
16bo4b4o$20b4ob2o$17b3o4bo$24bobo$28bo$24bo2b2o$25b3o$22b2o$21b3o5bo$
24b2o2bobo$21bo2b3obobo$22b2obo2bo$24bobo2b2o$26b2o$22b3o4bo$22b3o4bo$
23b2o3b3o$24b2ob2o$25b2o$25bo2$24b2o$26bo!

hvd answers:

The whole point of both of these options is to give the optimiser less leeway than it normally has. Therefore, unless you encounter a bug in the optimiser, the fastest should be to use neither, where the optimiser assumes your code doesn't have any overflows and doesn't emit code to handle overflows.

> What what does it mean when the -ftrapv definition says it generates "traps?" Does this mean exceptions?

It doesn't mean a C++ exception. It's target-dependent, but assuming x86, it means the GCC runtime libraries cause SIGABRT to be raised that will normally abort your program. On other platforms, it might use special CPU instructions that cause a hardware exception. It's mainly useful for debugging purposes and perhaps in a few cases for safety, where the risk of continuing after overflow is greater than the risk of the program suddenly terminating.

Former Carnegie Mellon University professor Yuji Ijiri, founder of the transitional momentum accounting practice, also known as triple-entry accounting, died on Jan. 18. He was 81.

Born Feb. 24, 1935, educated and employed as an accountant in his native Japan, Ijiri later adopted the Graduate School of Industrial Administration (GSIA), now the Tepper School of Business, and Carnegie Mellon University as his workplace and home for the final half-century of his life. He earned a Ph.D. in industrial administration at Carnegie Mellon in 1963 and, after four years at the Stanford Graduate School of Business, joined the faculty of GSIA. He remained a central Carnegie Mellon figure from 1967 until his death.

Until his retirement in 2011, Ijiri was the R.M. Trueblood University Professor of Accounting and Economics, emeritus. During his time in this position he collaborated and taught alongside such notables as Nobel laureate Herb Simon, former university president Richard Cyert, global operations and accounting visionary Bill Cooper, Ijiri’s thesis adviser James March, political scientist and co-author of the Behavioral Theory of the Firm, and global economics expert and Federal Reserve historian Allan Meltzer.

“Yuji played an instrumental role in the history of the Tepper School and is considered one of the intellectual giants of his era,” said Robert Dammon, dean of the Tepper School and professor of financial economics, who remembers his own 1984 arrival at the school, meeting the luminaries such as Simon and Ijiri. “Throughout his career, Yuji was an intellectual leader who had tremendous impact on the field of accounting, his colleagues, and the legions of Ph.D. students he worked with over the years. His influence and contributions have left an enduring legacy of research productivity and impact that sets one of the highest standards for academic achievement.”

Ijiri was named to the Accounting Hall of Fame in 1989, an honor afforded just 94 people through its 67-year history at Ohio State University. He authored 200 published papers and 25 books, some translated into Spanish, French and Japanese, but none more important to him than his 1989 work about triple-entry accounting. He was among the founding members of the Journal of Accounting and Public Policy in the early 1980s, as well as the only four-time winner of the American Accounting Association (AAA) Notable Contributions to Accounting Lecturer Award: 1966, 1967, 1971 and 1976. Ijiri served the AAA as vice president in the mid-1970s and president in the 1980s.

Ijiri, by his own description a “constant gardener” in education, once said, “Carnegie Mellon has indeed been ‘small gardens’ of learning blessed with exceptional teachers and students. Yet there seems to be something more. The gardens seem to have a special way of letting people grow.”

Ijiri was 6 years old when he attended the Abacus Math School in Kobe, Japan, and by the 10th grade was doing the bookkeeping for his father’s bakery. In 1952, before even graduating from the Nara High School of Commerce, he passed a test that allowed him to take the CPA examination without a college degree. He passed the CPA exam in 1953, while attending Doshisha Junior College at night. He finished three years at Ritsumeikan University, also in Kyoto, with a bachelor’s of law degree. Thus, he had completed all requirements for a CPA certificate at age 21, the youngest on record in Japan.

He worked at a small accounting firm and then with Price Waterhouse & Co. before leaving in 1959 to attend graduate school at the University of Minnesota, where he received a master’s degree in 1960. From there, he attended Carnegie Mellon, where he remained except for four years at Stanford.

Ijiri also was recognized internationally in accounting for aggregation theory, firm size distributions, accounting measurement theory, computer languages, and quantitative models in business and economics. Fair value accounting in the early 2000s brought his concepts to the forefront again, and among his final papers were works exploring connections between triple-entry accounting and quantum physics and quantum computing. At Carnegie Mellon, his service included academic councils, dean policy advisory and more. He was awarded the Weil Prize for faculty research in 2009-10. Established in 1990, the Yuji Ijiri Award for Excellence in Accounting is awarded to an MBA student during the school’s diploma ceremony each year.

Surviving are his wife of 54 years, Tomoko, of Oberlin, Ohio; and two daughters, Yumi (Oberlin, Ohio) and Lisa (Boston, Massachusetts).

Searchable and scriptable email in shell and emacs, yes please.

• Try using color or font weight to do the same job to differentiate importantness
• Stay away from font weights under 400 for UI work

1. Reduce the opacity of white text
2. Hand-pick a color that's base don the background color

• Material Design: Elevation and Shadows

1. Use a box shadow
2. Use two different background colors
3. Add extra spacing

1. CSS and HTML are extremely resilient, they ignore your typos and unsupported features gracefully and never crash, so just daring to use them in your code, no need for exception handling comparing to JS, in that sense, if you can do it in CSS, avoid JS.
2. Leverage CSS override
3. Use browser devtools to test all browsers. No need install all older browser to check CSS. icanuse helps greatly too.
4. Use feature-queries for CSS.

These indeed can make your CSS code work for both the stone age and hottest browsers, all at the same time, without much hacking. Great videos.

In this article I set out to answer some of the most common questions on sine and cosine, or trigonometry in general. I could give you a more mathematical explanation of sine and cosine, but I wanted this article to be of practical use to game programmers, especially to Allegro game programmers, not to give an encyclopedic description of abstract mathematics. I hope that this has been of some use to you, my dear reader. Please send me an e-mail if you have something to say about this article, whether you like it, dislike it, find it useful, or just want to say hi. If you have any questions you can ask them on the forums at http://www.allegro.cc/. It is very likely that I'll see it there. And if you ever write an effect in a demo or game using the explanations in this article, I would very much like to see the result.

Amarillion E-mail: amarillion@yahoo.com Home page: http://www.helixsoft.nl/

A bit dated now, especially with regards to consistency between implementations and support for modern features. However, many of the general concerns still ring true today.

A blog exploring C++ features and best practices with articles posted between 2005 and 2017.

C++ core guidelines maintained by Dr. Bjarne Stroustrup.

The Microsoft reference Guideline SUpport Library.

Alan Kay, I am the Alan Kay in question. Updated 2017 October 29.

First, let me clear up a few misconceptions from the previous answers. One of them said “Try writing an operating system with Lisp”, as though this would be somehow harder. In fact, one of the nicest operating systems ever done was on “The Lisp Machines” (in Zeta-Lisp), the hardware and software following the lead of “The Parc Machines” and Smalltalk — and we in turn had been very influenced by the Lisp model of programming and implementation. (These operating systems in both Smalltalk and Lisp were both better (claim) and easier to write (simpler to demonstrate) than the standard ones of today.)

Another interesting answer assumed that “the test of time” is somehow a cosmic optimization. But as every biologist knows, Darwinian processes “find fits” to an environment, and if the environment is lacking, then the fits will be lacking. Similarly, if most computer people lack understanding and knowledge, then what they will select will also be lacking. There is abundant evidence today that this is just what has happened.

But neither of these has anything to do with my praise of Lisp (and I did explain what I meant in more detail in “The Early History of Smalltalk”).

To start with an analogy, let’s notice that a person who has learned calculus fluently can in many areas out-think the greatest geniuses in history. Scientists after Newton were qualitatively more able than before, etc. My slogan for this is “Point of view is worth 80 IQ points” (you can use “context” or “perspective” etc.). A poor one might subtract 80 IQ points! (See above). A new more powerful one makes some thinking possible that was too difficult before.

One of our many problems with thinking is “cognitive load”: the number of things we can pay attention to at once. The cliche is 7±2, but for many things it is even less. We make progress by making those few things be more powerful.

This is one of the reasons mathematicians like compact notation. The downside is the extra layers of abstraction and new cryptic things to learn — this is the practice part of violin playing — but once you can do this, what you can think about at once has been vastly magnified. There were 20 Maxwell’s Equations in their original form (in terms of partial differentials and cartesian coordinates). Today the four equations we can think about all at once are primarily due to their reformulation by Heaviside to emphasize what is really important about them (and what is likely to be problematic — e.g. the electric and magnetic fields should probably be symmetric with respect to movement, etc).

Modern science is about experiencing phenomena and devising models whose relationships with the phenomena can be “negotiated”. The “negotiation” is necessary because what’s inside our heads, and our representations systems etc have no necessary connection to “what’s out there?”.

Taking this point of view, we can see there can be a “bridge science” and “bridge scientists” because engineers build bridges and these furnish phenomena for scientists to make models of.

Similarly, there can be a “computer science” and “computer scientists” because engineers build hardware and software and these furnish phenomena for scientists to make models of. (In fact, this was a large part of what was meant by “computer science” in the early 60s — and it was an aspiration — still is — not an accomplished fact).

The story behind Lisp is fun (you can read John McCarthy’s account in the first History of Programming Languages). One of the motivations was that he wanted something like “Mathematical Physics” — he called it a “Mathematical Theory of Computation”. Another was that he needed a very general kind of language to make a user interface AI — called “The Advice Taker” — that he had thought up in the late 50s.

He could program — most programs were then in machine code, Fortran existed, and there was a language that had linked lists.

John made something that could do what any programming language could do (relatively easy), but did it in such a way so that it could express the essence of what it was about (this was the math part or the meta part or the modern Maxwell’s Equations part, however you might like to think of it). He partly did this — he says — to show that this way to do things was “neater than a Turing Machine”.

Another observation about this is that the “slope” from the simplest machine structures to the highest level language was the steepest ever — meaning that the journey from recognizable hardware to cosmic expression is a rocket jump!

As is often the case — especially in engineering — a great scientific model is often superior to what exists, and can lead to much better artifacts. This was certainly true here. Steve Russell (later famous for being the main inventor and programmer of “SpaceWar”) looked at what John had done, and said: “That’s a program. If I coded it up we’d have a running version”. As John remarked: “He did, and we did”!

The result was “unlimited programming in an eyeful” (the bottom half of page 13 in the Lisp 1.5 manual). The key was not so much “Lisp” but the kinds of thinking that this kind of representational approach allowed and opened up regarding all kinds of programming language schemes.

A fun thing about it this is that once you’ve grokked it, you can think right away of better programming languages than Lisp, and you can think right away of better ways to write the meta descriptions than John did. This is the “POV = 80 IQ points” part.

But this is like saying that once you’ve seen Newton, it becomes possible to do electrodynamics and relativity. The biggest feat in science was Newton’s!

This is why “Lisp is the greatest!”

HEAD

HEAD is a special reference that always points to where the git repository is.

tag

A tag is a reference that points to a specifi commit.

branch

A branch is like a tag, but will move when the HEAD moves.

remote reference

A remote reference is a reference to code that’s from another repository.

Type out these commands and explain what’s going on. Take your time:

mkdir lgthw_origin
cd lgthw_origin
git init
echo 1 > afile
git add afile
git commit -m firstcommit
git log --oneline --decorate --all --graph
git branch otherbranch
git tag firstcommittag
git log --oneline --decorate --all --graph
echo 2 >> afile
git commit -am secondcommit
git checkout otherbranch
git log --oneline --decorate --all --graph
echo 3 >> afile
git commit -am thirdcommit
git log --oneline --decorate --all --graph

One can make a passive build much more powerful.

NSG S0, once out, will most likely be the go-to case for such setups. Until then, an HDPLEX H5 is cool.

My desk has a H5 on it, housing an i7 8700 (non-K) and a GTX 1060. The TIM under the heatspreader is replaced with Thermal Grizzly Conductonaut and Thermal Grizzly Kryonaut is used as every other TIM that the case setup needs. The CPU is on stock clocks with a voltage offset of -30 mV. The GPU has the power target reduced to 90% and clocks increased by 130 MHz, so that it is effectively undervolted as well. The PSU is a Seasonic Ultra Prime Titanium 650. Prime95 with AVX throttles really, really fast, under a minute, perhaps, but is a very unrealistic load. Non-AVX stress tests and FurMark take a while to start throttling (20 minutes?), as the thermal capacity of the aluminum case is quite big. After hours of gaming, the GPU and CPU float around 80 C while providing full stock performance. I don't do 3D rendering (other than in-game) or video en/decoding, so have not had long, real-world, full loads to see how temperatures behave with those.

From the discussion I've had and forums I've read, I think that people are afraid of putting more power in passive cases and having their components at "high" temperatures, despite those being rated for them.