Slashdot Mirror

• stackoverflow https://github.com/bosun-monit...
• ex-googlers https://github.com/cockroachdb...
• like bittorrent sync https://github.com/syncthing/s...
• drone.io CI https://github.com/drone/drone
• raft protocol implement https://github.com/goraft/raft which is used in a number of other projects such as the underlying projects in CoreOS (also written in Go)

and the list goes on and on with startups (http://blog.iron.io/2013/03/how-we-went-from-30-servers-to-2-go.html) and big names (https://github.com/dropbox/godropbox https://github.com/facebookgo) alike. Just google for more or explore github.

• stackoverflow https://github.com/bosun-monit...
• ex-googlers https://github.com/cockroachdb...
• like bittorrent sync https://github.com/syncthing/s...
• drone.io CI https://github.com/drone/drone
• raft protocol implement https://github.com/goraft/raft which is used in a number of other projects such as the underlying projects in CoreOS (also written in Go)

and the list goes on and on with startups (http://blog.iron.io/2013/03/how-we-went-from-30-servers-to-2-go.html) and big names (https://github.com/dropbox/godropbox https://github.com/facebookgo) alike. Just google for more or explore github.

• stackoverflow https://github.com/bosun-monit...
• ex-googlers https://github.com/cockroachdb...
• like bittorrent sync https://github.com/syncthing/s...
• drone.io CI https://github.com/drone/drone
• raft protocol implement https://github.com/goraft/raft which is used in a number of other projects such as the underlying projects in CoreOS (also written in Go)

and the list goes on and on with startups (http://blog.iron.io/2013/03/how-we-went-from-30-servers-to-2-go.html) and big names (https://github.com/dropbox/godropbox https://github.com/facebookgo) alike. Just google for more or explore github.

• stackoverflow https://github.com/bosun-monit...
• ex-googlers https://github.com/cockroachdb...
• like bittorrent sync https://github.com/syncthing/s...
• drone.io CI https://github.com/drone/drone
• raft protocol implement https://github.com/goraft/raft which is used in a number of other projects such as the underlying projects in CoreOS (also written in Go)

and the list goes on and on with startups (http://blog.iron.io/2013/03/how-we-went-from-30-servers-to-2-go.html) and big names (https://github.com/dropbox/godropbox https://github.com/facebookgo) alike. Just google for more or explore github.

.NET source comes with its own patent promise.

I used the Interwebs and had a choice of 3 or 4 perfectly good functions within about a minute.

That's how coding works today. And if you're not making use of other people's code you're not doing it right.

I wish someone had written a decent password strength meter years ago. One that could take any input without any restrictions, like spaces, greek, kanji etc..
Does the function measure entropy or do some sort of heuristics like counting upper and lower case letters?
Does it try a simple dictionary attack on the password? Can it handle more than 12 characters?
Can it handle me typing ALT+1 to add a smiley?(I notice slashdot strips those guys out).
I'm dubious of what sort of "perfectly good code" can be found on the interwebs. Ideally, it would come with its own unit test, with a whole slew of inputs and expected outputs. I found this one: https://github.com/syntaqx/pas... but, in your words: it's

not doing it right

They're taking it Mono a Mono. With nasty patent clauses, no doubt.

:) Microsoft's patent clauses are spelled out here https://github.com/dotnet/core...

I guess these are the key paragraphs:

Microsoft Corporation and its affiliates (“Microsoft”) promise not to assert any .NET Patents against you for making, using, selling, offering for sale, importing, or distributing Covered Code, as part of either a .NET Runtime or as part of any application designed to run on a .NET Runtime.

If you file, maintain, or voluntarily participate in any claim in a lawsuit alleging direct or contributory patent infringement by any Covered Code, or inducement of patent infringement by any Covered Code, then your rights under this promise will automatically terminate.

Disclaimer: I'm not a lawyer, but I am on Microsoft's VB/C# language team

MIT: https://github.com/Microsoft/d...

And the next one will probably be a distributed system that can't be shut down.

Also, they wrote a detection script: https://github.com/PaloAltoNet...

The future is being developed and we are already testing a marketplace that cannot be shutdown.

Decentralized marketplace for instantly trading uses blockchain technology, DHT, and mutisigniture arbitration.

https://openbazaar.org/

Beta 3 is about to be released. Join Us and support the future with a decentralized Ebay - https://github.com/OpenBazaar/...

http://tip4commit.com/projects/728

They conveniently leave out the part where most of the "poor workplace environments" and "mistreatment by managers and co-workers" are coming from the OTHER WOMEN. Prime well-known example: Julie Ann Horvath leaving GitHub...primarily because ANOTHER WOMAN harassed her incessantly.

And you "conveniently" left out any actual statistical evidence. And that it wasn't "primarily because another woman harassed her incessantly." You're forgetting the co-worker who professed his undying love for her, even though he knew she was already in a relationship with another employee, and he took her rejection badly - and retaliated.

There was definitely inappropriate behavior - GutHub acknowledges it here. If you've ever worked in a startup, you know how loosey-goosey things can get with the boss's family, since they feel they have tremendous skin in the game, having been there from the beginning, even if not in an official capacity. Even Bill Gates mom, Mary Gates (nee Maxwell), sat in on Microsoft board meetings for years.

But quitting over other women hula-hooping in the office and the guys ogling them doing so? Really?? Everything else she could put up with, but not this???

The final straw for Horvath came when she saw men gawking at women who were hula-hooping at the office. She called the episode “a really ugly and inappropriate scene.” Her words:

Two women, one of whom I work with and adore, and a friend of hers were hula hooping to some music. I didn’t have a problem with this. What I did have a problem with is the line of men sitting on one bench facing the hoopers and gawking at them. It looked like something out of a strip club. When I brought this up to male coworkers, they didn’t see a problem with it. But for me it felt unsafe and to be honest, really embarrassing. That was the moment I decided to finally leave GitHub.

She didn't ask the women how they felt about it - only the men. If they were okay with the men's reactions, where's the beef? Sounds to me like there's a certain immaturity on all sides.

Its easy to design an anonymous verifiable voting system using crypto (I don't think your proposed way solves all the problems, mainly secret ballots, but yes, there are ways). However its hard (if possible) to make one where selling your votes isn't equally verifiable: if I can prove my vote was or wasn't counted, generally I can prove to a third party how I voted thus I can sell them my vote. If this proof can be fully automated and done anonymously via bitcoin, vote selling would become super easy and completely safe. So do other forms of coercion.

I put some time into implementing such a system, but as documented here in the readme, there are basically unsolvable problems in the coercion and vote selling area. I haven't worked on the project much since some kind /. commenter pointed out the severity of the issue and I was unable to come up with a solution (thus it's in an unfinished unusable state). If you have anything better, please let me know. I hadn't thought of using the block chain (good idea!), but I think I found alternative solutions for the problems it solves.

Since then I've spend some time trying to design systems with somewhat different tradeoffs, but I haven't gotten anything really better than voting booths + some verifiability that your vote is counted while keeping secret ballot (a requirement for resisting coercion attacks).

You are clearly correct that just about anything (including your design) is better than the current electronic voting systems. Closed source uninspectiable systems that don't offer verifiability or even audibility are a joke, and advocating for or deploying them should be treason (Its worse than what Snowden did).

With 3C, you never divulge any information that can be used to generate future transactions. All transactions are controlled by the consumer.

3C can work with current point of sale devices. 3C WOPs can be pre-printed by ATMs or home printers, for example, and used like cash. Signing keys could be changed at will without having to wait for a new credit card to come in the mail.

See 3C explanation.

Yes, according to https://github.com/google/nogo...

Just to clarify, the poly counts I gave were actual triangles processed by the card when disabling texture-based rendering in Tao3D. This is the only case that always works, so it's both the fallback scenario and the worst case scenario. Therefore, that's the one I'm most interested in.

Not extruded? Why not render the text as a texture and slap it on a triangle strip?

Obviously, Tao3D does that when that's possible.

Why not render the glyphs as a large texture and make clever use of UV's?

Tao3D also does that when it makes sense.

(You'd use more triangles, 2 per character

Hmm, how do you draw a glyph with only one triangle per character? Or do you mean that we can use two triangles for multiple characters? We also can store full words in the glyph cache. But currently, we only use that for languages with ligatures such as Arabic.

but that's still way fewer than the approach you're using.

May I suggest that you should study how the Tao3D code works a little more before being so dismissive ;-)

You might also want to look at other, clearly more efficient, solutions. Take a look at three.js's ShapeGeometry. and ExtrudeGeometry -- A quick test shows great quality, with far fewer triangles.

Quick test with what? How did you create a text mesh with Three.js to start with?

Furthermore, as soon as you extrude, you need true polygonal rendering. You can't draw on a texture and render quads or two triangles as you suggested. Or if there's a way, I don't know it. So you end up with roughly the number of polygons in the base glyph x N, where N depends on extrusion parameters, e.g. if you create a bezel or not, if you round the bezel, and so on.

That being said, if you want the text to look any good, you have to emit a large number of triangles for even relatively simple text.

On the basis of my experience, I strongly disagree.

Would you please be kind enough to share your experience? That's a hot topic for me.

First, I'd like to point out that even if you can do texture-based rendering, you still need to first render to a texture with polygons or, alternatively, with triangles and a shader doing the Bezier fill.

Let's deal with two cases here. The first case is when texture-based glyph caching applies. In that case, polygon count is rarely a problem for alphabetic languages. For ideographic languages, or languages with ligatures such as Arabic, the chances of finding what you need in the glyph cache are lower, but you can still assume you will draw the same text several frames in a row, so that's still a net win. The animation may skip a bit when the text changes though... So basically, the glyph polygon count defines the worst case "skip" you can get. And westerners don't care, since they use a Latin alphabet with an appropriately low number of glyphs. So in general, we can reuse entries in the glyph cache.

Second case is when you can't use textures. Extruded 3D text is one scenario, that's hardly the only one. Then, you need true polygonal rendering. And the number of basic triangles you had for the front face is multiplied by N, which depends on the shape of the extrusion path (bezel, rounded bezel, etc). Plus this time, you need to render the polygons at every single frame, so polygon counts start playing a big role in performance.

In all cases, even with an curvature-dependent algorithm, you still need a decent number of polygons per glyph or any non-basic font looks like crap. I think the best you can do is something like one triangle per Bezier curve in the glyph (un

Just to clarify, the poly counts I gave were actual triangles processed by the card when disabling texture-based rendering in Tao3D. This is the only case that always works, so it's both the fallback scenario and the worst case scenario. Therefore, that's the one I'm most interested in.

Not extruded? Why not render the text as a texture and slap it on a triangle strip?

Obviously, Tao3D does that when that's possible.

Why not render the glyphs as a large texture and make clever use of UV's?

Tao3D also does that when it makes sense.

(You'd use more triangles, 2 per character

Hmm, how do you draw a glyph with only one triangle per character? Or do you mean that we can use two triangles for multiple characters? We also can store full words in the glyph cache. But currently, we only use that for languages with ligatures such as Arabic.

but that's still way fewer than the approach you're using.

May I suggest that you should study how the Tao3D code works a little more before being so dismissive ;-)

You might also want to look at other, clearly more efficient, solutions. Take a look at three.js's ShapeGeometry. and ExtrudeGeometry -- A quick test shows great quality, with far fewer triangles.

Quick test with what? How did you create a text mesh with Three.js to start with?

Furthermore, as soon as you extrude, you need true polygonal rendering. You can't draw on a texture and render quads or two triangles as you suggested. Or if there's a way, I don't know it. So you end up with roughly the number of polygons in the base glyph x N, where N depends on extrusion parameters, e.g. if you create a bezel or not, if you round the bezel, and so on.

That being said, if you want the text to look any good, you have to emit a large number of triangles for even relatively simple text.

On the basis of my experience, I strongly disagree.

Would you please be kind enough to share your experience? That's a hot topic for me.

First, I'd like to point out that even if you can do texture-based rendering, you still need to first render to a texture with polygons or, alternatively, with triangles and a shader doing the Bezier fill.

Let's deal with two cases here. The first case is when texture-based glyph caching applies. In that case, polygon count is rarely a problem for alphabetic languages. For ideographic languages, or languages with ligatures such as Arabic, the chances of finding what you need in the glyph cache are lower, but you can still assume you will draw the same text several frames in a row, so that's still a net win. The animation may skip a bit when the text changes though... So basically, the glyph polygon count defines the worst case "skip" you can get. And westerners don't care, since they use a Latin alphabet with an appropriately low number of glyphs. So in general, we can reuse entries in the glyph cache.

Second case is when you can't use textures. Extruded 3D text is one scenario, that's hardly the only one. Then, you need true polygonal rendering. And the number of basic triangles you had for the front face is multiplied by N, which depends on the shape of the extrusion path (bezel, rounded bezel, etc). Plus this time, you need to render the polygons at every single frame, so polygon counts start playing a big role in performance.

In all cases, even with an curvature-dependent algorithm, you still need a decent number of polygons per glyph or any non-basic font looks like crap. I think the best you can do is something like one triangle per Bezier curve in the glyph (un

Just to clarify, the poly counts I gave were actual triangles processed by the card when disabling texture-based rendering in Tao3D. This is the only case that always works, so it's both the fallback scenario and the worst case scenario. Therefore, that's the one I'm most interested in.

Not extruded? Why not render the text as a texture and slap it on a triangle strip?

Obviously, Tao3D does that when that's possible.

Why not render the glyphs as a large texture and make clever use of UV's?

Tao3D also does that when it makes sense.

(You'd use more triangles, 2 per character

Hmm, how do you draw a glyph with only one triangle per character? Or do you mean that we can use two triangles for multiple characters? We also can store full words in the glyph cache. But currently, we only use that for languages with ligatures such as Arabic.

but that's still way fewer than the approach you're using.

May I suggest that you should study how the Tao3D code works a little more before being so dismissive ;-)

You might also want to look at other, clearly more efficient, solutions. Take a look at three.js's ShapeGeometry. and ExtrudeGeometry -- A quick test shows great quality, with far fewer triangles.

Quick test with what? How did you create a text mesh with Three.js to start with?

Furthermore, as soon as you extrude, you need true polygonal rendering. You can't draw on a texture and render quads or two triangles as you suggested. Or if there's a way, I don't know it. So you end up with roughly the number of polygons in the base glyph x N, where N depends on extrusion parameters, e.g. if you create a bezel or not, if you round the bezel, and so on.

That being said, if you want the text to look any good, you have to emit a large number of triangles for even relatively simple text.

On the basis of my experience, I strongly disagree.

Would you please be kind enough to share your experience? That's a hot topic for me.

First, I'd like to point out that even if you can do texture-based rendering, you still need to first render to a texture with polygons or, alternatively, with triangles and a shader doing the Bezier fill.

Let's deal with two cases here. The first case is when texture-based glyph caching applies. In that case, polygon count is rarely a problem for alphabetic languages. For ideographic languages, or languages with ligatures such as Arabic, the chances of finding what you need in the glyph cache are lower, but you can still assume you will draw the same text several frames in a row, so that's still a net win. The animation may skip a bit when the text changes though... So basically, the glyph polygon count defines the worst case "skip" you can get. And westerners don't care, since they use a Latin alphabet with an appropriately low number of glyphs. So in general, we can reuse entries in the glyph cache.

Second case is when you can't use textures. Extruded 3D text is one scenario, that's hardly the only one. Then, you need true polygonal rendering. And the number of basic triangles you had for the front face is multiplied by N, which depends on the shape of the extrusion path (bezel, rounded bezel, etc). Plus this time, you need to render the polygons at every single frame, so polygon counts start playing a big role in performance.

In all cases, even with an curvature-dependent algorithm, you still need a decent number of polygons per glyph or any non-basic font looks like crap. I think the best you can do is something like one triangle per Bezier curve in the glyph (un

Please, visit http://livecode.com/download/ and download the most recent version of LiveCode Community Edition (Open Source) for your OS: (Linux, MacOS X, Windows) If you visit this webpage: http://downloads.livecode.com/... you will find all downloads available, including stable public releases, release candidates and developer previews. Choose one of the stable releases and install it in your computer. Then, you will understand why many developers still cherish and remember fondly, it's first encounter with HyperCard. You could download Livecode's source code from Git: https://github.com/runrev/live... Learn about Livecode's quality controls at: http://quality.runrev.com/ By the way, HyperCard found it's way to many platforms in the form of clones: For Commodore Amiga, there was UltraCard (later renamed Foundation): http://www.dreamtimestudioz.co... For Linux, there was MetaCard (today Open Source LiveCode): http://www.metacard.com/ For Windows, Oracle Media Objects: http://en.wikipedia.org/wiki/O...

Thought for the day: whenever designing something for other people to use, you should take all feedback from your potential users and prove to yourself why the feedback is correct before attempting to show the giver why it's wrong.

Why? Firstly, because nobody will give you any feedback at all if your default response is to prove to everyone that their feedback is so valueless to you (and if you don't want feedback, then this whole thread is just self-promotion, which isn't popular here).

Secondly, because we all make mistakes, so there are bound to be things in our work that are suboptimal. Admitting to yourself that there is a mistake doesn't necessarily mean having to change it -- if you honestly assess the impact of the mistake and say it's something your happy to live with, great. But it has to be a conscious decision, not denial of the problem.

Thirdly, both sides can be right, and often are. If our disagreement comes from different assumptions and use cases, you might find that if you open the dialogue (rather than shouting "FUD"), you might hear of a problem you hadn't thought of. You need to see it from not only the angle you choose to follow, but also the angle you have already rejected.

Now...

I don't like subroutine names that include something that looks like a parameter, so things like rotatex and rotatey set me on edge a bit.

If you prefer, you can use the plain rotate. But rotating along X, Y or Z is frequent enough to deserve a shortcut. Not different from CSS transform, by the way.

It gets worse when this is inconsistent, and you see a subroutine called vertical_align for vertical alignment, where the seeming parameter (vertical) is now before the generic (align), and separated by an underscore instead of run together. Not only is this an internal inconsistency, but it's inconsistent with English, as "align" is a verb, and we would put in an adverb "vertically" after the verb normally. And then it gets worse again, as the command for horizontal alignment is... "align".

You are right, align_vertically would be more sensible. Exercise for you: fix it ;-)

Exercise for you: go **** yourself. That's just patronising. I'm giving you feedback, and the implication of your statement -- regardless of the smiley -- is that my feedback is valueless if I'm not willing to code it up myself. I'll say it again: if you want feedback, don't tell people you don't care about their feedback.

As for align, that's the common case, so I'd rather keep it that way.

[Citation needed] If we were just talking about text flow in a 2D page, I would agree with you, but there's so much geometry in here, I personally don't see any default.

The grammatical inconsistency continues with other commands/subroutines taking on names with no verb component at all (eg the command color, with no verb or assignment operator.

That derives from OpenGL, which has glRotate and glTranslate, but glColor and not glColorize. BUT it's not inconsistent. It's actually fairly smart. The color is an attribute, and glColor just sets it. So the name is the name of the attribute you set. glRotate and glTranslate modify an attribute (the current model/view matrix), so they are verbs.

I understand that, but it's wrong. I know a lot of people laugh at the idea of using setColor and getColor as per so many OO style guides, but really, you either need to use assignments or use verb-based names, or the syntax is broken from a human cognitive perspective. It is very difficult to reason about a grammar

I don't like subroutine names that include something that looks like a parameter, so things like rotatex and rotatey set me on edge a bit.

If you prefer, you can use the plain rotate. But rotating along X, Y or Z is frequent enough to deserve a shortcut. Not different from CSS transform, by the way.

It gets worse when this is inconsistent, and you see a subroutine called vertical_align for vertical alignment, where the seeming parameter (vertical) is now before the generic (align), and separated by an underscore instead of run together. Not only is this an internal inconsistency, but it's inconsistent with English, as "align" is a verb, and we would put in an adverb "vertically" after the verb normally. And then it gets worse again, as the command for horizontal alignment is... "align".

You are right, align_vertically would be more sensible. Exercise for you: fix it ;-) As for align, that's the common case, so I'd rather keep it that way.

The grammatical inconsistency continues with other commands/subroutines taking on names with no verb component at all (eg the command color, with no verb or assignment operator.

That derives from OpenGL, which has glRotate and glTranslate, but glColor and not glColorize. BUT it's not inconsistent. It's actually fairly smart. The color is an attribute, and glColor just sets it. So the name is the name of the attribute you set. glRotate and glTranslate modify an attribute (the current model/view matrix), so they are verbs. Unwittingly, I applied the same logic for things that change the color state, e.g. show. Since show changes the color state, it is a verb.

I'm really not happy with the way pattern matching is used as overloading ...because you can get yourself in a mess if you split it up into different parts of the code and accidentally overwrite stuff.

How is this different from overloading? That's a FUD argument. In reality, its distributed nature is exactly what makes the construct powerful. It offers a very flexible dynamic dispatch mechanism.

For example, the Slides module draws a background for slides using theme_background. That function is provided by the default theme. But most themes will override it.

In general, this override happens only on part of the pattern. For example, most slide elements are defined by (theme, master), sometimes (theme, master, style). The "master" is the equivalent of the Powerpoint "slide master", i.e. it defines the layout, etc. If you define a new theme, you'll typically define overrides that catch everything for a given theme (e.g. for "BrightRectangles" in the last link). But you may also want to override for a specific combination.

I'm completely baffled why the whole demo recreates the shapes for every single redraw frame rather than keeping them as persistent objects (which necessitates adding a random seed in order to fake them being persistent by pulling up the same colours each time.

The Tao3D drawing model is a feature, not a bug. If you write rectangle 0, 0, 320, 200, it draws the rectangle once, and that's

I don't like subroutine names that include something that looks like a parameter, so things like rotatex and rotatey set me on edge a bit.

If you prefer, you can use the plain rotate. But rotating along X, Y or Z is frequent enough to deserve a shortcut. Not different from CSS transform, by the way.

It gets worse when this is inconsistent, and you see a subroutine called vertical_align for vertical alignment, where the seeming parameter (vertical) is now before the generic (align), and separated by an underscore instead of run together. Not only is this an internal inconsistency, but it's inconsistent with English, as "align" is a verb, and we would put in an adverb "vertically" after the verb normally. And then it gets worse again, as the command for horizontal alignment is... "align".

You are right, align_vertically would be more sensible. Exercise for you: fix it ;-) As for align, that's the common case, so I'd rather keep it that way.

The grammatical inconsistency continues with other commands/subroutines taking on names with no verb component at all (eg the command color, with no verb or assignment operator.

That derives from OpenGL, which has glRotate and glTranslate, but glColor and not glColorize. BUT it's not inconsistent. It's actually fairly smart. The color is an attribute, and glColor just sets it. So the name is the name of the attribute you set. glRotate and glTranslate modify an attribute (the current model/view matrix), so they are verbs. Unwittingly, I applied the same logic for things that change the color state, e.g. show. Since show changes the color state, it is a verb.

I'm really not happy with the way pattern matching is used as overloading ...because you can get yourself in a mess if you split it up into different parts of the code and accidentally overwrite stuff.

How is this different from overloading? That's a FUD argument. In reality, its distributed nature is exactly what makes the construct powerful. It offers a very flexible dynamic dispatch mechanism.

For example, the Slides module draws a background for slides using theme_background. That function is provided by the default theme. But most themes will override it.

In general, this override happens only on part of the pattern. For example, most slide elements are defined by (theme, master), sometimes (theme, master, style). The "master" is the equivalent of the Powerpoint "slide master", i.e. it defines the layout, etc. If you define a new theme, you'll typically define overrides that catch everything for a given theme (e.g. for "BrightRectangles" in the last link). But you may also want to override for a specific combination.

I'm completely baffled why the whole demo recreates the shapes for every single redraw frame rather than keeping them as persistent objects (which necessitates adding a random seed in order to fake them being persistent by pulling up the same colours each time.

The Tao3D drawing model is a feature, not a bug. If you write rectangle 0, 0, 320, 200, it draws the rectangle once, and that's

I don't like subroutine names that include something that looks like a parameter, so things like rotatex and rotatey set me on edge a bit.

If you prefer, you can use the plain rotate. But rotating along X, Y or Z is frequent enough to deserve a shortcut. Not different from CSS transform, by the way.

It gets worse when this is inconsistent, and you see a subroutine called vertical_align for vertical alignment, where the seeming parameter (vertical) is now before the generic (align), and separated by an underscore instead of run together. Not only is this an internal inconsistency, but it's inconsistent with English, as "align" is a verb, and we would put in an adverb "vertically" after the verb normally. And then it gets worse again, as the command for horizontal alignment is... "align".

You are right, align_vertically would be more sensible. Exercise for you: fix it ;-) As for align, that's the common case, so I'd rather keep it that way.

The grammatical inconsistency continues with other commands/subroutines taking on names with no verb component at all (eg the command color, with no verb or assignment operator.

That derives from OpenGL, which has glRotate and glTranslate, but glColor and not glColorize. BUT it's not inconsistent. It's actually fairly smart. The color is an attribute, and glColor just sets it. So the name is the name of the attribute you set. glRotate and glTranslate modify an attribute (the current model/view matrix), so they are verbs. Unwittingly, I applied the same logic for things that change the color state, e.g. show. Since show changes the color state, it is a verb.

I'm really not happy with the way pattern matching is used as overloading ...because you can get yourself in a mess if you split it up into different parts of the code and accidentally overwrite stuff.

How is this different from overloading? That's a FUD argument. In reality, its distributed nature is exactly what makes the construct powerful. It offers a very flexible dynamic dispatch mechanism.

For example, the Slides module draws a background for slides using theme_background. That function is provided by the default theme. But most themes will override it.

In general, this override happens only on part of the pattern. For example, most slide elements are defined by (theme, master), sometimes (theme, master, style). The "master" is the equivalent of the Powerpoint "slide master", i.e. it defines the layout, etc. If you define a new theme, you'll typically define overrides that catch everything for a given theme (e.g. for "BrightRectangles" in the last link). But you may also want to override for a specific combination.

I'm completely baffled why the whole demo recreates the shapes for every single redraw frame rather than keeping them as persistent objects (which necessitates adding a random seed in order to fake them being persistent by pulling up the same colours each time.

The Tao3D drawing model is a feature, not a bug. If you write rectangle 0, 0, 320, 200, it draws the rectangle once, and that's

I don't like subroutine names that include something that looks like a parameter, so things like rotatex and rotatey set me on edge a bit.

If you prefer, you can use the plain rotate. But rotating along X, Y or Z is frequent enough to deserve a shortcut. Not different from CSS transform, by the way.

It gets worse when this is inconsistent, and you see a subroutine called vertical_align for vertical alignment, where the seeming parameter (vertical) is now before the generic (align), and separated by an underscore instead of run together. Not only is this an internal inconsistency, but it's inconsistent with English, as "align" is a verb, and we would put in an adverb "vertically" after the verb normally. And then it gets worse again, as the command for horizontal alignment is... "align".

You are right, align_vertically would be more sensible. Exercise for you: fix it ;-) As for align, that's the common case, so I'd rather keep it that way.

The grammatical inconsistency continues with other commands/subroutines taking on names with no verb component at all (eg the command color, with no verb or assignment operator.

That derives from OpenGL, which has glRotate and glTranslate, but glColor and not glColorize. BUT it's not inconsistent. It's actually fairly smart. The color is an attribute, and glColor just sets it. So the name is the name of the attribute you set. glRotate and glTranslate modify an attribute (the current model/view matrix), so they are verbs. Unwittingly, I applied the same logic for things that change the color state, e.g. show. Since show changes the color state, it is a verb.

I'm really not happy with the way pattern matching is used as overloading ...because you can get yourself in a mess if you split it up into different parts of the code and accidentally overwrite stuff.

How is this different from overloading? That's a FUD argument. In reality, its distributed nature is exactly what makes the construct powerful. It offers a very flexible dynamic dispatch mechanism.

For example, the Slides module draws a background for slides using theme_background. That function is provided by the default theme. But most themes will override it.

In general, this override happens only on part of the pattern. For example, most slide elements are defined by (theme, master), sometimes (theme, master, style). The "master" is the equivalent of the Powerpoint "slide master", i.e. it defines the layout, etc. If you define a new theme, you'll typically define overrides that catch everything for a given theme (e.g. for "BrightRectangles" in the last link). But you may also want to override for a specific combination.

I'm completely baffled why the whole demo recreates the shapes for every single redraw frame rather than keeping them as persistent objects (which necessitates adding a random seed in order to fake them being persistent by pulling up the same colours each time.

The Tao3D drawing model is a feature, not a bug. If you write rectangle 0, 0, 320, 200, it draws the rectangle once, and that's

I don't like subroutine names that include something that looks like a parameter, so things like rotatex and rotatey set me on edge a bit.

If you prefer, you can use the plain rotate. But rotating along X, Y or Z is frequent enough to deserve a shortcut. Not different from CSS transform, by the way.

It gets worse when this is inconsistent, and you see a subroutine called vertical_align for vertical alignment, where the seeming parameter (vertical) is now before the generic (align), and separated by an underscore instead of run together. Not only is this an internal inconsistency, but it's inconsistent with English, as "align" is a verb, and we would put in an adverb "vertically" after the verb normally. And then it gets worse again, as the command for horizontal alignment is... "align".

You are right, align_vertically would be more sensible. Exercise for you: fix it ;-) As for align, that's the common case, so I'd rather keep it that way.

The grammatical inconsistency continues with other commands/subroutines taking on names with no verb component at all (eg the command color, with no verb or assignment operator.

That derives from OpenGL, which has glRotate and glTranslate, but glColor and not glColorize. BUT it's not inconsistent. It's actually fairly smart. The color is an attribute, and glColor just sets it. So the name is the name of the attribute you set. glRotate and glTranslate modify an attribute (the current model/view matrix), so they are verbs. Unwittingly, I applied the same logic for things that change the color state, e.g. show. Since show changes the color state, it is a verb.

I'm really not happy with the way pattern matching is used as overloading ...because you can get yourself in a mess if you split it up into different parts of the code and accidentally overwrite stuff.

How is this different from overloading? That's a FUD argument. In reality, its distributed nature is exactly what makes the construct powerful. It offers a very flexible dynamic dispatch mechanism.

For example, the Slides module draws a background for slides using theme_background. That function is provided by the default theme. But most themes will override it.

In general, this override happens only on part of the pattern. For example, most slide elements are defined by (theme, master), sometimes (theme, master, style). The "master" is the equivalent of the Powerpoint "slide master", i.e. it defines the layout, etc. If you define a new theme, you'll typically define overrides that catch everything for a given theme (e.g. for "BrightRectangles" in the last link). But you may also want to override for a specific combination.

I'm completely baffled why the whole demo recreates the shapes for every single redraw frame rather than keeping them as persistent objects (which necessitates adding a random seed in order to fake them being persistent by pulling up the same colours each time.

The Tao3D drawing model is a feature, not a bug. If you write rectangle 0, 0, 320, 200, it draws the rectangle once, and that's

The fact that its grammar cannot be expressed as EBNF (like Ada) does not mean that it's not precise and consistent.

I wasn't objecting to the fact that it can't be expressed in EBNF, but the reason you gave -- that so much of the language can be redefined at will. Suddenly you have to look in dozens of different places to verify what the most basic features of the language are.

Overall, the grammar is much more consistent than most other languages, if only because it's so small. As I indicated elsewhere in this discussion, scanner and parser together represent some 1500 lines of C++ code, and a syntax file that is currently 62 lines long. A complete and precise description of the core language in plain english takes about 50 pages. Compare that to the 700 pages for the C++ standard, and tell me which one is easier to teach?

Lisp has a tiny grammar and a small standard, and that leaves us buggering about with a visual confusion of brackets and parentheses. The point of high-level languages is to impose a more human-freindly logic over the CPU's instruction set.

What I need is not so much a consistent grammar as a consistent behaviour -- the expressive logic of the language must be consistent, and if the basic behaviour of the language is overridable at will, then it is not consistent from day to day, or from job to job.

Metaprogramming is a powerful paradigm, because it allows you to take a general purpose language and make out of it a language optimised to the particular task you are trying to achieve. But Tao3D (as you present it) is a language with a very narrow, dedicated purpose: it's 3D-Powerpoint-on-steroids. Why on Earth is anyone going to want to override operator precedence for making a presentation? And once they've done it, are they going to remember they've done it? Are they going to remember the next time?

If you want to look at your input in a Lisp-ish syntax, you can, there's an option in the compiler to dump the parse tree in such a format.

That's technically possible with any language. But if I need that to debug my code, then the published spec is inadequate.

Anyway, I've got a more specific critique here. I'd like to see your response to that.

The fact that its grammar cannot be expressed as EBNF (like Ada) does not mean that it's not precise and consistent.

I wasn't objecting to the fact that it can't be expressed in EBNF, but the reason you gave -- that so much of the language can be redefined at will. Suddenly you have to look in dozens of different places to verify what the most basic features of the language are.

Overall, the grammar is much more consistent than most other languages, if only because it's so small. As I indicated elsewhere in this discussion, scanner and parser together represent some 1500 lines of C++ code, and a syntax file that is currently 62 lines long. A complete and precise description of the core language in plain english takes about 50 pages. Compare that to the 700 pages for the C++ standard, and tell me which one is easier to teach?

Lisp has a tiny grammar and a small standard, and that leaves us buggering about with a visual confusion of brackets and parentheses. The point of high-level languages is to impose a more human-freindly logic over the CPU's instruction set.

What I need is not so much a consistent grammar as a consistent behaviour -- the expressive logic of the language must be consistent, and if the basic behaviour of the language is overridable at will, then it is not consistent from day to day, or from job to job.

Metaprogramming is a powerful paradigm, because it allows you to take a general purpose language and make out of it a language optimised to the particular task you are trying to achieve. But Tao3D (as you present it) is a language with a very narrow, dedicated purpose: it's 3D-Powerpoint-on-steroids. Why on Earth is anyone going to want to override operator precedence for making a presentation? And once they've done it, are they going to remember they've done it? Are they going to remember the next time?

If you want to look at your input in a Lisp-ish syntax, you can, there's an option in the compiler to dump the parse tree in such a format.

That's technically possible with any language. But if I need that to debug my code, then the published spec is inadequate.

Anyway, I've got a more specific critique here. I'd like to see your response to that.

For the algorithms, I'll let you look at the code :-) It's mostly in path3d.cpp, text_drawing.cpp and glyph_cache.cpp.

There are several algorithms that are activated separately depending on: whether you draw flat text or extruded 3D text; whether there's a texture or not; the size of the font; and more. The primary ones are: render to textures and draw quads, render polygons for the outline and play that back, or extrude the outline with triangle strips. Then there are some tricks to minimize the number of triangles emitted. I also tried an approach where we rendered triangles and there was a fragment shader doing the bezier curve inside each triangle. That was surprisingly very inefficient on many low-end graphic cards, so I stashed it without going through with it.

That being said, if you want the text to look any good, you have to emit a large number of triangles for even relatively simple text. The text of the previous paragraph is 69475 triangles in Arial, 138950 when extruded, 171298 polygons in font "Amaze" not even extruded, 265636 with the font "Be safe", 561930 with font IthornÎt, and ... a whopping 2171202 with Apple's "Chalkduster" font.

That still doesn't answer my question about what you think is lacking in WebGL.

1. Performance (which is getting good on desktop-class devices thanks to improvements in Javascript compilation, but still terrible e.g. on mobile devices).
2. Portability. I gave as an example the fact that using a mere GLSL shader as a background on my tutorial page made it unusable for a good fraction of the readers.
3. At the time we started, Microsoft still had the position that they would never support it. They changed their mind only last year, remember? So anybody using IE before 11 has no WebGL.

For the algorithms, I'll let you look at the code :-) It's mostly in path3d.cpp, text_drawing.cpp and glyph_cache.cpp.

There are several algorithms that are activated separately depending on: whether you draw flat text or extruded 3D text; whether there's a texture or not; the size of the font; and more. The primary ones are: render to textures and draw quads, render polygons for the outline and play that back, or extrude the outline with triangle strips. Then there are some tricks to minimize the number of triangles emitted. I also tried an approach where we rendered triangles and there was a fragment shader doing the bezier curve inside each triangle. That was surprisingly very inefficient on many low-end graphic cards, so I stashed it without going through with it.

That being said, if you want the text to look any good, you have to emit a large number of triangles for even relatively simple text. The text of the previous paragraph is 69475 triangles in Arial, 138950 when extruded, 171298 polygons in font "Amaze" not even extruded, 265636 with the font "Be safe", 561930 with font IthornÎt, and ... a whopping 2171202 with Apple's "Chalkduster" font.

That still doesn't answer my question about what you think is lacking in WebGL.

1. Performance (which is getting good on desktop-class devices thanks to improvements in Javascript compilation, but still terrible e.g. on mobile devices).
2. Portability. I gave as an example the fact that using a mere GLSL shader as a background on my tutorial page made it unusable for a good fraction of the readers.
3. At the time we started, Microsoft still had the position that they would never support it. They changed their mind only last year, remember? So anybody using IE before 11 has no WebGL.

For the algorithms, I'll let you look at the code :-) It's mostly in path3d.cpp, text_drawing.cpp and glyph_cache.cpp.

There are several algorithms that are activated separately depending on: whether you draw flat text or extruded 3D text; whether there's a texture or not; the size of the font; and more. The primary ones are: render to textures and draw quads, render polygons for the outline and play that back, or extrude the outline with triangle strips. Then there are some tricks to minimize the number of triangles emitted. I also tried an approach where we rendered triangles and there was a fragment shader doing the bezier curve inside each triangle. That was surprisingly very inefficient on many low-end graphic cards, so I stashed it without going through with it.

That being said, if you want the text to look any good, you have to emit a large number of triangles for even relatively simple text. The text of the previous paragraph is 69475 triangles in Arial, 138950 when extruded, 171298 polygons in font "Amaze" not even extruded, 265636 with the font "Be safe", 561930 with font IthornÎt, and ... a whopping 2171202 with Apple's "Chalkduster" font.

That still doesn't answer my question about what you think is lacking in WebGL.

1. Performance (which is getting good on desktop-class devices thanks to improvements in Javascript compilation, but still terrible e.g. on mobile devices).
2. Portability. I gave as an example the fact that using a mere GLSL shader as a background on my tutorial page made it unusable for a good fraction of the readers.
3. At the time we started, Microsoft still had the position that they would never support it. They changed their mind only last year, remember? So anybody using IE before 11 has no WebGL.

Except when it doesn't just work and you have to debug, because then what you describe as "dynamic" starts to feel like "unpredictable" and it takes far longer to work through than it should. I've only looked at a very small example, but I cannot imagine myself ever trying to teach how to program in this language. How do you teach someone to think like something with very little internal logic or consistency?

The fact that its grammar cannot be expressed as EBNF (like Ada) does not mean that it's not precise and consistent. You look at some input and at the xl.syntax file, and you know exactly what parse tree you are getting out of that input. You look at the various rewrite rules (the things given by the rewrite operator -> and you know exactly what's going to be executed and why.

Overall, the grammar is much more consistent than most other languages, if only because it's so small. As I indicated elsewhere in this discussion, scanner and parser together represent some 1500 lines of C++ code, and a syntax file that is currently 62 lines long. A complete and precise description of the core language in plain english takes about 50 pages. Compare that to the 700 pages for the C++ standard, and tell me which one is easier to teach?

If you want to look at your input in a Lisp-ish syntax, you can, there's an option in the compiler to dump the parse tree in such a format. If you build the command-line compiler for XLR, it will be xlr -parse file.xl -style debug -show. You can also try -style dbghtml to see it create HTML coloured boxes corresponding to the program structure. For example, if you have the default syntax file, input http://pastebin.com/TTbCKshW turns into http://pastebin.com/wxZX2Fc0. It's absolutely deterministic.

The additional grammar rules I mentioned earlier, e.g. the distinction between statement and expression, are there to match the way we humans read code. That's what concept programming is about.

Except when it doesn't just work and you have to debug, because then what you describe as "dynamic" starts to feel like "unpredictable" and it takes far longer to work through than it should. I've only looked at a very small example, but I cannot imagine myself ever trying to teach how to program in this language. How do you teach someone to think like something with very little internal logic or consistency?

The fact that its grammar cannot be expressed as EBNF (like Ada) does not mean that it's not precise and consistent. You look at some input and at the xl.syntax file, and you know exactly what parse tree you are getting out of that input. You look at the various rewrite rules (the things given by the rewrite operator -> and you know exactly what's going to be executed and why.

Overall, the grammar is much more consistent than most other languages, if only because it's so small. As I indicated elsewhere in this discussion, scanner and parser together represent some 1500 lines of C++ code, and a syntax file that is currently 62 lines long. A complete and precise description of the core language in plain english takes about 50 pages. Compare that to the 700 pages for the C++ standard, and tell me which one is easier to teach?

If you want to look at your input in a Lisp-ish syntax, you can, there's an option in the compiler to dump the parse tree in such a format. If you build the command-line compiler for XLR, it will be xlr -parse file.xl -style debug -show. You can also try -style dbghtml to see it create HTML coloured boxes corresponding to the program structure. For example, if you have the default syntax file, input http://pastebin.com/TTbCKshW turns into http://pastebin.com/wxZX2Fc0. It's absolutely deterministic.

The additional grammar rules I mentioned earlier, e.g. the distinction between statement and expression, are there to match the way we humans read code. That's what concept programming is about.

Except when it doesn't just work and you have to debug, because then what you describe as "dynamic" starts to feel like "unpredictable" and it takes far longer to work through than it should. I've only looked at a very small example, but I cannot imagine myself ever trying to teach how to program in this language. How do you teach someone to think like something with very little internal logic or consistency?

The fact that its grammar cannot be expressed as EBNF (like Ada) does not mean that it's not precise and consistent. You look at some input and at the xl.syntax file, and you know exactly what parse tree you are getting out of that input. You look at the various rewrite rules (the things given by the rewrite operator -> and you know exactly what's going to be executed and why.

Overall, the grammar is much more consistent than most other languages, if only because it's so small. As I indicated elsewhere in this discussion, scanner and parser together represent some 1500 lines of C++ code, and a syntax file that is currently 62 lines long. A complete and precise description of the core language in plain english takes about 50 pages. Compare that to the 700 pages for the C++ standard, and tell me which one is easier to teach?

If you want to look at your input in a Lisp-ish syntax, you can, there's an option in the compiler to dump the parse tree in such a format. If you build the command-line compiler for XLR, it will be xlr -parse file.xl -style debug -show. You can also try -style dbghtml to see it create HTML coloured boxes corresponding to the program structure. For example, if you have the default syntax file, input http://pastebin.com/TTbCKshW turns into http://pastebin.com/wxZX2Fc0. It's absolutely deterministic.

The additional grammar rules I mentioned earlier, e.g. the distinction between statement and expression, are there to match the way we humans read code. That's what concept programming is about.

And I heard of Readable Lisp for those of us who don't like so much parens. Sure, still need some inside lines, but why would you want a language that seems to parse "200 * sin time" and "rotate_y 20 * time" at the same time?

And of the things I have played with recently, the example looks just like layout definition in Scaloid.

The actual definition of if-then-else can be found here. It looks like this:

// If-then-else statement
if true then TrueBody else FalseBody -> do TrueBody
if false then TrueBody else FalseBody -> do FalseBody

if true then TrueBody -> do TrueBody
if false then TrueBody -> false

The definition of the 'for' loop is more convoluted and is actually found in C++ code. It looks like this:

FORM(IntegerForLoop, tree,
          "for Var in Low:integer..High:integer loop Body",
          PARM(Var, tree, "")
          PARM(Low, integer, "")
          PARM(High, integer, "")
          PARM(Body, source, ""),
          return xl_integer_for_loop(context,self, &Var, Low, High, 1, &Body), )
FORM(IntegerForLoopStep, tree,
          "for Var in Low:integer..High:integer by Step:integer loop Body",
          PARM(Var, tree, "")
          PARM(Low, integer, "")
          PARM(High, integer, "")
          PARM(Step, integer, "")
          PARM(Body, source, ""),
          return xl_integer_for_loop(context,self, &Var, Low,High,Step, &Body), )
FORM(RealForLoop, tree,
          "for Var in Low:real..High:real loop Body",
          PARM(Var, tree, "")
          PARM(Low, real, "")
          PARM(High, real, "")
          PARM(Body, source, ""),
          return xl_real_for_loop(context,self, &Var, Low, High, 1.0, &Body), )

The actual definition of if-then-else can be found here. It looks like this:

// If-then-else statement
if true then TrueBody else FalseBody -> do TrueBody
if false then TrueBody else FalseBody -> do FalseBody

if true then TrueBody -> do TrueBody
if false then TrueBody -> false

The definition of the 'for' loop is more convoluted and is actually found in C++ code. It looks like this:

FORM(IntegerForLoop, tree,
          "for Var in Low:integer..High:integer loop Body",
          PARM(Var, tree, "")
          PARM(Low, integer, "")
          PARM(High, integer, "")
          PARM(Body, source, ""),
          return xl_integer_for_loop(context,self, &Var, Low, High, 1, &Body), )
FORM(IntegerForLoopStep, tree,
          "for Var in Low:integer..High:integer by Step:integer loop Body",
          PARM(Var, tree, "")
          PARM(Low, integer, "")
          PARM(High, integer, "")
          PARM(Step, integer, "")
          PARM(Body, source, ""),
          return xl_integer_for_loop(context,self, &Var, Low,High,Step, &Body), )
FORM(RealForLoop, tree,
          "for Var in Low:real..High:real loop Body",
          PARM(Var, tree, "")
          PARM(Low, real, "")
          PARM(High, real, "")
          PARM(Body, source, ""),
          return xl_real_for_loop(context,self, &Var, Low, High, 1.0, &Body), )

If you want this on OSX (or windows?) you could install ifuse: https://github.com/libimobiled... . . Not sure how to get it to mount a automatically when the device is plugged in though.

There is a list of generation times on a 1.5 Ghz processor that can be found on the Shallot repository which also includes software to do it.

This one? It sounds awesome just by reading the project description.

https://github.com/YePpHa/YouT... youtube fucking your way.

- A Metasploit module is available for testing:

https://github.com/rapid7/meta...

wget prior to 1.16 allows for a web server to write arbitrary files on the client side.

A Metasploit module is available for testing:

https://github.com/rapid7/meta...

the disclosure is here:

https://community.rapid7.com/c...

Redhat's bug is here:

https://bugzilla.redhat.com/sh...

But it's easier to parse HTML5 than it was any previous version of HTML, as there is now an actual specification which details the process exactly rather than relying on each browser's interpretation. It can't be that difficult given the number of working parsers and validators out there for HTML5.

Plus, HTML5 can already be written using XML syntax, aka XHTML5. And searching for xhtml5.xsd or xhtml5.rng gave me plenty of links to schemas for validating XML-syntax HTML5.

If you need to store validated documents, then you shouldn't be storing them in HTML format! Store them as XML documents with well-defined schemas (Relax NG of course!), and then use XSLT or possibly XQuery to turn them into HTML fragments for display.

Sounds like it is GraphViz.

It is a bummer that such a nice project is in a state like that. I would recommend a lot to make a fork in GitHub so that the source code has more visibility.

Also, someone touched a very good point. A lot of young people are now focusing on Web technologies (like JS). Are you aware of vis.jz ? (a port of GraphViz engine to JavaScript) We use it were I work now to very quickly visualize graphs.

I really like the Dot language, and after tinkering with several JS graphing programs, I concluded that GraphViz layout algorithm is the best (for big graphs, pretty much all the others showed crap, while GV shows a decent image).

It's actually called Pulse now and it's source can be found on Github under the old name.

Seems to be https://github.com/ellson/grap...

Also, why does the website need a machine? Throw it on the free GitHub pages and you'll be fine there.

I have the same issues with OS/2 source code. Not been able to attract new and younger programmers and many of the source code is scattered on the web with the risk of being lost.

I'm doing the following:
1) I had organized all source code I was able to find on GitHub:
- Created a Organization on github - https://github.com/os2world
- Organized the repos in "named-categories"
2) Created a Wiki to organize the catalog.
3) I will upload a copy of all repositories and a wiki dump to the Internet Archive. http://www.archive.org/

This are my steps to try that the source code do not get lost.

The problem with "a traditional interpreter in C" is that Perl6 code can change how it's parsed.
Which means that the easiest language to date with which to write a parser for Perl6, is Perl6.

Which is why the Rakudo implementation is written mostly in Perl6 and NQP (Not Quite Perl).

Speaking of C level stuff there is a new VM designed specifically for the Rakudo implementation of Perl6, MoarVM.
You can also run Rakudo on the JVM.

The problem with "a traditional interpreter in C" is that Perl6 code can change how it's parsed.
Which means that the easiest language to date with which to write a parser for Perl6, is Perl6.

Which is why the Rakudo implementation is written mostly in Perl6 and NQP (Not Quite Perl).

Speaking of C level stuff there is a new VM designed specifically for the Rakudo implementation of Perl6, MoarVM.
You can also run Rakudo on the JVM.

Couldn't write a proper wear levelling algorithm if their life depended on it.

First the MAG4FA/KYL00M/VYL00M data corruption bug that affected the Galaxy Nexus - https://android.googlesource.c...

Then (actually BEFORE it, Google found it during Galaxy Nexus development but Samsung kept it hush-hush - but it became a public issue much later) - the infamous Samsung Superbrick fiasco (If you fired a secure erase command at the chip, it had a chance of permanently corrupting the wear leveller data to the point where the chip's onboard controller would crash until you power cycled it any time you accessed that region of flash). - https://git.kernel.org/cgit/li...

Then pre-release 840 PRO devices suffer from the SAME DAMN BUG SAMSUNG HAD BEEN AWARE OF FOR OVER A YEAR - http://www.anandtech.com/show/... - While this only affected review devices, the fact that this was a known bug since before the release of the Galaxy Nexus (a year earlier) is inexcusable.

Then there was the Galaxy S3 "Sudden Death Syndrome" issue in late 2013... - https://github.com/omnirom/and...

Then there were a few other issues - http://wiki.cyanogenmod.org/w/...

Now this...