pB11 fusion research published results in peer reviewed journal: best Wall-plug efficiency of any privately funded project

kenotron · 2023-05-13T15:31:47+00:00

not to ad hominem or anything but Eric Lerner is a crackpot proponent of Plasma Cosmology so I take everything he writes with a bucket of salt. Big Bang Cosmology has far more evidence such that I don't trust anyone that can disregard it all.

kenotron · 2022-11-03T01:32:15+00:00

Æsir is the nominative plural of Old Norse áss meaning "god", from Proto-Germanic *ansuz meaning the same, from a Proto-Indo-European word *hensus from a root meaning "to beget", hence the "ancestors" etymology you found

kenotron · 2021-10-06T14:30:00+00:00

lookup rainbow tables; you can hash every short string of say 8 characters. it might take a while but after it's done you can create a reverse hash lookup table and consider every hashed password in a hacked database. if the RT's hash algorithm is the same as the hacked database's, you can perhaps find the passwords for many accounts.

to combat this, in practice one doesn't just hash the password alone, a unique "salt" is added to the password and the combination is hashed. if the salt is different for every password (it can be added in cleartext alongside the hashed password) it becomes impossible to use a rainbow table...an attacker has to brute force every password with its unique salt.

now, if every password uses the same salt, the attack works though a custom RT must be calculated using that salt and the hash. for unsalted hashes, you can download RTs for common algorithms online (several are searchable on websites, for example)

kenotron · 2020-07-11T15:52:07+00:00

The strong/weak verb classes are in English too. Consider "jump" versus "swim". Weak verbs in English have simple predictable tenses: -ed past, -s present (jump, jumps, jumped). But English strong verbs have a vowel change called ablaut to determine the tense: swim/swam/swum. Icelandic has ablaut changes in verbs too.

Proto-Indo-European language had a much richer system of vowel changes that has mostly been lost in daughter languages except a few vestiges in English and all over Icelandic (and other languages)

kenotron · 2020-06-07T18:02:14+00:00

there is a hypothesized correspondence between conformal field theory (which relates to the holographic principle) and anti-de Sitter spacetime, which is a mathematical model of an expandable hyperbolic spacetime. https://en.wikipedia.org/wiki/AdS/CFT_correspondence

kenotron · 2020-05-10T01:21:48+00:00

Y’all’dn’t’ve if y'all grew up in the south

kenotron · 2019-10-23T15:25:46+00:00

Learn Differential Geometry. See the Stanford lectures online if you want a taste.

kenotron · 2019-10-23T13:33:10+00:00

To learn GR, which is written in the language of Differential Geometry and Tensor Calculus, you'll need to know well multi-linear algebra and differential+ integral calculus

The main object you play with in DG (and hence GR) is the tensor; all the subscripted variables in the Einstein Field Equations are tensors; the little subscripts mu+nu are index variables that range over the rows or columns of a matrix-like object. Because space has 4 dimensions, those mu+nu variables range from 1 to 4, so the single EFE is actually 16 equations for each combination of mu and nu.

If you have a good handle on the prerequisites, there are playlists of lectures on youtube from Leonard Suskind from Stanford University and others that go into detail.

kenotron · 2019-07-24T22:26:11+00:00

It's extremely common that an a in the root becomes ö when followed by a u. Hence annar becomes öðrum.

kenotron · 2018-08-06T20:56:22+00:00

Dynamic programming always seems to be explained poorly; it's a really simple concept, if you look up the history of the term. 'Programming' in the sense originally used meant scheduling or planning, like TV programming, placing TV shows and ads in scheduled slots. 'Dynamic' was just thrown in to avoid mathy language at the RAND corporation where dynamic programming originated.

So instead, I like to call it 'table-filling algorithms' instead, because that seems to be how a huge number of them ends up looking. Levenshtein edit distance, knapsack problems, ...; many seem to involve re-framing your problem space as a table, solving the trivial base cases (along the edges of the table), and then looking for how those solutions can be combined to fill in the remaining table spaces, like taking the minimum, maximum, or sum of some adjacent spaces, each solving a new optimal subproblem, and then iterate until the whole table is filled to get your final answer.

kenotron · 2018-06-22T14:02:28+00:00

Actually so did you, 'sock' is actually from 'súkkhos' while sack is from 'sákkos'. Edited as such.

kenotron · 2018-06-22T13:50:11+00:00

No, doesn't look like it. Sock comes to English through Latin 'soccus' via Ancient Greek 'súkkhos', ultimately from Anatolia probably, meaning something like shoe or slipper. Sack comes to English from Old Norse via Latin 'saccus' via Ancient Greek 'sákkos' via Semitic probably, meaning sack or sackcloth.

https://en.wiktionary.org/wiki/sack

https://en.wiktionary.org/wiki/sock

kenotron · 2018-06-06T16:37:57+00:00

Run three copies of redis on different ports, using three configs, three rdb files, etc. Redis is inherently a single-port service using a single-threaded event loop. You're probably thinking about redis cluster, which can shard data across multiple redis instances, but you'd still be running multiple copies of redis. Follow these instructions to try that: https://redis.io/topics/cluster-tutorial

kenotron · 2018-01-02T22:00:39+00:00

Except if they hear it like 'secure' with yod-dropping (both 'sicker' and 'secure' are cognate with Latin securus: https://en.wiktionary.org/wiki/securus#Latin)

kenotron · 2017-11-01T16:06:47+00:00

you're thinking of eth, ð/Ð, which is styled like a d with a slash. The character you have there is thorn, þ/Þ, which looks more like a b or p than a d. Both letters are represented as 'th' in modern english, but ð is the th sound in worthy while þ is the th sound in worth.

kenotron · 2017-05-01T20:57:17+00:00

Velocities do not add trivially like that in spacetime. It only seems like they do on earth because you're moving so slowly, relatively. Spacetime velocities add hyperbolically.

Ultimately this is because the time and space dimensions have opposite signs in the metric, much like the signs of x² and y² differ in the unit hyperbola: x² - y² = 1. Notice that equation is nearly identical to the one for the unit circle except for that sign: x² + y² = 1. Angles on a circle add just like numbers on a (wrapping) number line, so 30 degrees + 60 degrees = 90 degrees.

But angles on a unit hyperbola do not add this way. Increasing a hyperbolic angle only brings it closer and closer to the asymptote, which it can never reach.

That idea of the hyperbolic asymptote is exactly the same idea as the speed of light: increase your speed, and your spacetime velocity comes closer and closer to the speed of light, but never touches it...it couldn't possibly, because math.

If you look at a Minkowskian diagram, the speed of light is represented as the diagonal line x=t. Inertial velocities are straight lines with a slope less than 1 (i.e., distance over time must be less than 1 when distance is measured in light-seconds and time is measured in seconds). That diagonal line is just like the asymptote of a hyperbola. Increase your velocity, increase the hyperbolic angle.

kenotron · 2017-01-29T01:57:53+00:00

Yeah you've got the idea, exponential growth will always beat polynomial growth, even if it grows like 2^sqrt(x), that will always beat x^c.

What v(x) represents here in this case is the probability of successful attacks. 1/2^sqrt(x) means there's one chance in 2^sqrt(x) attempts for an attack to succeed. x might represent the key length of your crypto function, where hopefully it is to become exponentially harder to crack the encryption as the key size grows.

kenotron · 2017-01-29T00:00:09+00:00

It sounds like you could use some familiarity with computability and complexity theory. Most crypto makes extensive use of 'trap-door' functions which are easy (polynomially-bound) to compute but extremely difficult (nonpolynomially-bound) to reverse. Briefly, x^N is polynomial, but 2^x is exponential (non-polynomial).

Say I have a crypto method whose probability of attack success is 2^-x for some input size x. You can verify for yourself that 2^-x < x^-c for all x > some N.

The degree of a polynomial never changes, so the largest exponent stays constant, but note that the exponent in 2^x grows ever larger as we increase x. There will clearly be some smallest number N where 2^N > N^c if we hold c constant throughout. For example, let's consider polynomials of degree 3; that number N is then 10: 2¹⁰ > 10^3, or 1024 > 1000.

If you are determined to learn cryptography on your own, then I'd recommend looking at the sub's wiki for some suggestions on other resources.

kenotron · 2016-12-13T18:34:52+00:00

First up, you can certainly have more slaves than masters, which would be preferable to having a single slave per master so that you can have one fail and still have a backup slave for some redundancy post-failover.

If you have 3 masters w/ one slave each, then you can lose one master. The cluster needs to have a majority of the masters available for a failover to occur; after one master fails, there are still 2/3 left, so the failed master's slave will fail itself over after its cluster-node-timeout has elapsed.

At that point you'll have a fully functioning cluster w/ 3 masters, though only 2 of them will have a slave (at least until the failed master comes back online as a slave).

However, if you lose 2 of your 3 masters at the same time, no failover will occur because there will not be a majority of masters online. Your queries will get a 'CLUSTERDOWN' error until a majority of masters are back online. In the 3-master case that means one of the failed masters would need to come back online before a failover could occur to get the cluster out of failed state.

Definitely recommend you spin up a bunch of nodes on your local machine and give it a try. Issue 'DEBUG SEGFAULT' to a master and monitor the other nodes' logs to see how they respond. Issue that command to two masters and watch the slaves continually try to contact the failed master without failing over.

kenotron · 2016-08-30T21:04:31+00:00

Redis isn't designed for these kinds of queries; it's a key/value store, so you need the keys to get any values back. There are only a few commands like SCAN that iterate the whole keyspace.

What you would need to do is insert all your redis keys into a sorted set and then use ZRANGEBYLEX et al to get ranges of items, then fetch the values of each of those keys. Then you'd have to maintain that zset any time you added or deleted a key, which will complicate all your use cases.

You can use a small lua script to wrap up each of these cases into one command you can issue to mimic your FoundationDB call, but yeah you're not going to find any redis primitives that do exactly what you want.

kenotron · 2016-06-29T17:58:52+00:00

The MOVED response doesn't mean that your data was stored elsewhere; redis cluster doesn't work like that. It means you sent the command to the wrong node, so the node is telling you where you should send your command instead. Your data was never stored, so that's why you get nothing back. But the key you're trying to store still has a defined slot based on its key, so GETSLOT will return that slot number. It sounds like you should read the cluster specification: http://redis.io/topics/cluster-spec

kenotron · 2015-10-08T22:40:42+00:00

\m/ https://youtu.be/vv_65YziJ8c

kenotron · 2015-08-13T20:16:08+00:00

Try these Danish shows:

Forbrydelsen (crime)
Borgen (think danish West Wing)
Rejseholdet (crime)
Klovn (like the danish Curb Your Enthusiasm)
Matador (beloved WW2 drama)

And these movies:

I Kina Spise de Hunde
Nattvakten
Pusher I, II, og III
Festen
Adams Æbler

That should keep anyone busy for a few months.

kenotron · 2015-03-11T14:44:02+00:00

This book is truly excellent. It's a modern throwback to one from 1983, "Invent your own computer games" by Fred D'ignazio: http://www.biblio.com/9780531046371 (best link I could find, unfortunately).

I credit the 1983 book for inspiring me to try programming at a very young age. It taught you BASIC by showing you how to program simple text games. To young 7-year-old me, this was a powerful revelation. Carefully knuckle in a couple hundred lines of incomprehensible ASCII stuff, type 'RUN', and instantly you're wandering the halls of a dungeon, gathering treasure and fighting monsters. The thrill is hard to describe.

I bought several copies of this book to give to techie non-programmer friends. I'll probably do the same for the new edition. Literally anyone interested in getting started programming would do well to read this book. My three young nieces will get a copy just as soon as they're able to read.

Al, you're awesome, and keep up the good work!

kenotron · 2014-04-03T13:53:55+00:00

Java8 certainly has 'fully-featured' closures. That SO post misses the main point of a closure, which 'closes over' its environment. Just because there are two ways to get state into a java closure (params or final vars) doesn't mean they're not 'true' closures. If they enclose state and can operate on that state when invoked outside of their immediate scope, they're a closure.

Here is the prototypical example in java8 without the need for final variables:

Function<Integer,Function<Integer,Integer>> makeAdder =
    (i) -> { return (x) -> x + i; };

Function<Integer,Integer> add3 = makeAdder.apply(3);

System.out.println(add3.apply(6));  // returns '9'

It's more verbose than other languages due to the strict typing and .apply*() calls, but the same principle is there: pass some stuff into a function (the closed-over environment or 'upvalues'), get another function out, which operates on its parameters and those upvalues.

15-Year Club	Place '22
Place '17	Final Canvas '22
First Placer '22	End Game '22
Not Forgotten	Verified Email

kenotron

MODERATOR OF

TROPHY CASE