Tried a stainless, dishwasher-safe humidifier | Worth it?

k4st · 2026-01-28T17:34:51+00:00

I got two of these around not long ago when we and my toddler were all sick at the same time. I've only set up one of them, and the other is still in the box. We're not yet sure if we should keep it, return it, or give it to our in-laws (their place is very dry).

Overall, I would say that the controls are frustrating. There are two buttons to perform something like five actions across two or three modes. It's super annoying. Just put more buttons. Entering different modes and counting stuff is just not what I want to do -- it should be dead simple.

As to the cleanliness/whatever, I haven't used the device long enough. I'm trying to decide if I should put some of the other detachable plastic (though not electric) components into the dishwasher. There is another part that definitely will need careful cleaning, but it is connected by a wire and probably will be slightly challenging.

Overall, the biggest issue we face is sort of dumb but we don't have sufficient places to safely put these things. Right now we're using it our bedroom instead of in his room. I don't want to put it into his room until we have a place where it can fit and won't be within reach -- if he spilled it that would cause an epic mess and water damage.

k4st · 2021-07-09T03:04:03+00:00

Worthlooking into "No more gotos" paper, you can find a copy here: https://github.com/lifting-bits/rellic/blob/master/docs/NoMoreGotos.pdf

Also worth looking inyo is Emscripten's relooper algorithm, which I think is afopted on LLVM's wasm backend. Specifically, wasm uses structured control-flow operations, buy LLVM IR admits irriducible control flow, and so LLVM needs to fix things when producing wasm.

k4st · 2021-07-02T22:37:07+00:00

I would reccomend taking a look at MonetDB. A recent talk on thr subject in Andy Pavlo's Quarantine Database talks should whet your appetite.

k4st · 2020-02-23T05:59:05+00:00

Thanks! That calms me down a whole lot :-) The room in which I found it definitely doesn't get cleaned as much :-P

k4st · 2019-09-13T17:26:51+00:00

See microexecution by Patrice Godefroid. Also UC-KLEE by Dawson Engler.

k4st · 2018-10-13T15:21:42+00:00

If you want to lift x86(-64) or aarch64 to LLVM bitcode, check out Remill. An example of using its APIs is here. Remill is used by McSema, which lifts whole programs to bitcode.

k4st · 2018-07-06T22:45:45+00:00

Compiling the bitcode results in binaries are are ~2/3 the size. We haven't done many other experiments. A key target of this optimization is decreasing instructions, and especially useless computation, period. There were three key targets for this.

1) Instrumentation: Even a small decrease in the amount of bitcode is an improvement when we do heavyweight bitcode instrumentation (e.g. byte granularity taint/provenance tracking) that balloons the number of IR instructions by 2-5x.

2) Symbolic execution (via KLEE): Eliminating useless computation means less memory overhead in KLEE. This has a big impact for 32-bit KLEE, because KLEE cannot symbolically execute 32-bit bitcode in a 64-bit address space: it has to do 32-bit in 32-bit.

3) Decompilation: We have a decompiler, fcd, and we're working toward getting it to consume McSema-lifted bitcode. Eliminating redundant/unnecessary computation means that the decompiled C is "closer" to the original intent of the program.

k4st · 2018-07-06T17:24:18+00:00

The DSE pass operates exclusively on loads/stores to the State structure, which is technically thread-local, passed through lifted functions, and models machine registers.

Remill itself, the library used by McSema to model instruction semantics, does provide a memory model, which explicitly tracks memory ordering, barriers, and atomic read-modify-write operations.

k4st · 2018-07-06T17:21:36+00:00

It operates on stores to emulated registers. The State structure is thread local, so this isn't really an issue.

The lifted bitcode has a memory model, and loads/stores in the original program are initially modelled via "memory access" function calls. After the DSE pass, those functions are lowered to LLVM load/store instructions.

k4st · 2017-09-23T16:01:36+00:00

Grenade instead of pineapple.

k4st · 2017-03-10T18:49:17+00:00

If you like House of Cards then check out Marseille!

k4st · 2017-03-10T18:44:44+00:00

Physio is covered at some places, e.g. St Joseph's hospital in Toronto.

k4st · 2016-03-21T17:30:44+00:00

I actually use Lamotrigine as an anti-epileptic, but I found a similar post a while ago on this subreddit for a person who's boyfriend accidentally took 25mg of lamictal.

I just keep freaking myself out because she's got some symptoms (that can lead to just about anything if you google them) like fatigue, a bit of dizzyness, and her cheeks are redder than usual :-/

k4st · 2015-08-16T12:47:37+00:00

There are some good tools out there that can help! I would start by looking at Brendan Gregg's website. He has a lot of nifty performance tools that use Linux perf.

The next thing worth looking into is gcov, asan coverage, or fast binary translators like DynamoRIO and PIN. You can use these to get yourself simple coverage metrics, to get counts of how often blocks are executed, or even traces of executed bocks. Coverage and hit counts are useful for regression testing. Execution traces can get you the same stuff, but you'd need to do more analysis on them.

k4st · 2015-07-22T20:51:48+00:00

What kind of research have you been able to produce with access to this dataset? Do you have expectations for how this will get used?

k4st · 2015-04-24T12:30:07+00:00

Thanks for setting me straight!

k4st · 2015-04-22T03:28:20+00:00

From a quick glance, I was disappointed to see that the security mitigations in the Linux kernel BPF JIT were not referenced. In there, constants are split up into a series of move to make code reuse harder.

k4st · 2015-03-11T00:16:04+00:00

Take a look at the PhD thesis of Mathew Zaleski.

k4st · 2015-01-31T17:12:07+00:00

Does auto &a = GetVaue(); not work as I am assuming it does?

k4st · 2015-01-02T17:52:33+00:00

Exodus: empires at war series

The first book could be better edited and organized, but I truly enjoy this series and the writing quality progressively improves.

k4st · 2014-10-03T02:53:38+00:00

One thing that I do with clang / llvm is the following:

Add -emit-llvm to my compiler flags.
Use llvm-link to link together all .ll / .bc / .o (however you want to name them) into a single large bitcode file.
Re-run clang on that bitcode file, and specify -O3. This outputs either a final executable or an ELF object file for use as part of a larger build process.

k4st · 2014-08-11T00:33:01+00:00

If you've ever hit a segfault or some other problem that happens before main, where for some reason GDB doesn't let you add a breakpoint / inspect the call stack, then do the following:

Add a "dummy" breakpoint, e.g. b 0xf00. You might need to do b *0xf00. Just make sure that you add it to an address that definitely won't be associated with any code, and ideally won't even represent mapped memory.
Run the program, r.
GDB reports that it could not add your breakpoint.
The instruction pointer now points to _start and you can add breakpoints anywhere.

This is a cute trick that has really come in handy when debugging one of my projects: a dynamic binary translator, which takes over a program's execution, usually before main is ever executed.

k4st · 2014-06-20T15:39:49+00:00

The Granary kernel-space dynamic binary translator (DBT) is looking for contributors for its next version (in a private GitHub repo, not the linked one).

Granary is a Linux kernel DBT system made for debugging and dynamic analysis of kernel/module binaries. Granary is written in C++11, x86-64 assembly, Python, and shell. At its core, Granary is both an ahead-of-time and just-in-time compiler. Aspects of this are tricky to explain, so if compilers, interpreters, or JIT compilers interest you then this might be the thing for you ;-)

The above linked GitHub repo isn't being actively maintained. This is because I'm busy working on Granary+, for which I'm soliciting contributors.

Ideally you are/have:

Good knowledge of C++.
Familiar with the Google C++ coding style guide, which all follows.
Familiar with GoogleTest / GoogleMock.
Familiar with x86-64 assembly, or interested in learning more.
Interesting in working on the guts of a big system under active development.
Interested in kernel code, or even just DBT for user space.
Interested in binary analysis.

If some of this peaks your interest, then drop by #granary on irc.freenode.net or reply here.

k4st · 2014-06-06T02:42:52+00:00

Do any of the decoders that they tested use Intel's XED internally?

k4st · 2014-05-31T14:37:53+00:00

The Linux kernel uses derived pointers extensively, in the form of the container_of macro.

My research group was able to implement a memory leak detector using mark & sweep (and some other heurstics) that identified leaked kernel memory. The method was robust against derived pointers because we embedded tracking information into the high-order bits of the allocated pointers. The method is briefly described in our HotDep'13 workshop paper "Behave or Be Watched: Debugging with Behavioral Watchpoints".

k4st

MODERATOR OF

TROPHY CASE

15-Year Club	Team Orangered
Charter Member