2,059,334 events, 1,203,257 push events, 1,637,392 commit messages, 91,101,316 characters
Run 4.93 miles
Got hot in Eugene again. On Sunday I did a 8 mile hike up the south sister with Anna and Christine. I think my legs were sort of sore for this one. I cut it a bit short because we had early dinner plans, but I was happy for the excuse.
Fuckin crazy shit man. CHanged a bunch of shit.. I don't know. Such good music tho.
Add files via upload
Cancer begins when healthy cells change and grow out of control, forming a mass or sheet of cells called a tumor. A tumor can be cancerous or benign. A cancerous tumor is malignant, meaning it can grow and spread to other parts of the body. A benign tumor means the tumor can grow but will not spread. When breast cancer is limited to the breast and/or nearby lymph node regions, it is called early stage or locally advanced. When breast cancer spreads to an area farther from where it started, doctors say that the cancer has “metastasized.” They call the area of spread a “metastasis,” or “metastases” if the cancer has spread to more than 1 area. The disease is called metastatic breast cancer. Another name for metastatic breast cancer is “stage IV (4) breast cancer.” Doctors may also call metastatic breast cancer “advanced breast cancer.” However, this term should not be confused with “locally advanced breast cancer,” which is breast cancer that has spread to nearby tissues or lymph nodes but not to other parts of the body. Metastatic breast cancer is last stage of breast cancer. At this stage cancer cells have spread to other parts of body beyond the axillary lymph nodes. There is no cure for metastatic breast cancer. Breast cancer can metastasize anywhere in body but primarily metastasizes to the bone, lungs, regional lymph nodes, liver and brain, with the most common site being the bone. Treatment of metastatic breast cancer depends on location of the metastatic tumors and includes surgery, radiation, chemotherapy, biological, and hormonal therapy. There are several types of breast cancer, and any of them can metastasize. Most breast cancers start in the ducts and are called ductal carcinomas They start in the cells lining the milk ducts and make up the majority of breast cancers. Lobular carcinoma is cancer that starts in the lobules. Less common types of breast cancer include Medullary, Mucinous, Tubular, Metaplastic and Papillary breast cancer. Inflammatory breast cancer is a faster-growing type of cancer that accounts for about 1 percent to 5percent of all breast cancers. Paget’s disease is a type of cancer that begins in the ducts of the nipple. Breast cancer can develop in women and men. However, breast cancer in men is rare. Less than 1 percent of all breast cancers develop in men. Each year, an estimated 279,100 people (276,480 women and 2,620 men) in the United States will be diagnosed with invasive breast cancer. Breast cancer is the most common cancer in women, excluding skin cancer. About 6 percent of women have metastatic breast cancer when they are first diagnosed. More research is needed to determine how many people with non-metastatic breast cancer later develop metastatic breast cancer. Breast cancer is the second most common cause of death from cancer in women. It is estimated that 42,690 people (42,170 women and 520 men) will die from breast cancer this year. Metastatic breast cancer will cause the vast majority of those deaths. The 5-year survival rate tells you what percent of people live at least 5 years after the cancer is found. Percent means how many out of 100. The 5-year survival rate for women with metastatic breast cancer is 27 percent. The 5-year survival rate for men with metastatic breast cancer is 22 percent. Over the past decade, there has been a steady decline in the breast cancer (BC) death rate mainly due to innovative management pathways, from early detection to treatment. Nonetheless, Breast cancer still remains the number one cause of deaths among females worldwide . In this respect, Breast Cancer metastatic prediction is a challenging task that could greatly benefit from the development of predictive models. Contemporary oncology has shown a renewed focus in information technology. The integration of big healthcare data has raised new hopes for personalized medicine. For nearly 20 years, Artificial intelligence (AI) and machine learning (ML) have been used to diagnose and classify cancer , but only limited studies have explored their relevance in cancer prognosis. ML or semi-supervised learning techniques have been recently applied in the field of Breast Cancer progression and survivability to develop models. Thus, the development of prognostic classification models highlights the value of the AI technologies that can be used to predict outcomes in individual cancer patients for personalized patient care and in numerous different medical problems. In our research we have used data of genes to give prognosis of most likely where cancer can spread as secondary tumor from breast cancer.
State machine generation nearly works
The parser is almost able to generate state machines from a given line of text, it just needs more testing to be certain it works. There's a known bug with repetition and nested token grouops (e.g. from parentheses), but the fix should be fairly straightforward.
After getting this polished off, next steps are generating the parse tree from the results of running the automata over a line of text from the choices file, and figuring out how to handle the non-ABNF tokens, and whether that will take the form of extending the automata to a push-down automata, or if we'll just use a hack for it.
Also moved files into a subfolder because it was kinda silly I had everything in one folder.
Persistent block metadata may now have mutable parts Not allowing this makes stuff like anvil damage, colour, wood type, live/dead bit, wet/dry etc all too much hassle to deal with. Naturally I want to get rid of this shit altogether, but first it's necessary to construct a new system that we can shift into before all this bullshit can be addressed fully, so for now we have to work within the bounds of the old system. This change will permit dynamic colours for concrete/concrete powder etc, dynamic wood types where the wood type isn't embedded in the legacy ID, and so forth. Allowing full flexibility requires either more old system hacks or completing the migration to a new system which doesn't have these limitations. I prefer to do the latter, but this change will make it somewhat easier to do.
Farewell...
Today, Friday 17th August 2018, marks 2 years, 2 months, and 2 days since my first contribution to the Waterfall project (that’s a total of 792 days!). Throughout that time, 3 major Minecraft versions have been released, Waterfall has become the go-to for modded networks, and Sponge has become a very viable option for servers - no longer lacking in implementation.
Before the Bukkit drama, I had written very little software for the server - though I’d written a bunch of fairly basic client mods. I had run a bunch of servers however - I had very extensive knowledge of the Classic server software, and I’d run a lot of bukkit servers. Though vanilla has never really been my cup-of-tea, and ever since I started to do a lot of work with the server my time playing the game has decreased. The truth is, I’ve never played any of those 3 major releases that have come out since I’ve been maintaining Waterfall.
Sadly I have fallen out of love with the game, and don’t see myself likely to play it anytime soon. However, I find a certain joy in writing software so I’ve stuck around - the communities I’ve landed on are really great :D I’ve found projects to work on that are independent from Minecraft, yet keep me within the same communities.
Today I work on a lot of software related to obfuscation and Java - namely Lorenz, Bombe, and Survey. Though I’m also a web developer for Sponge, in addition to a bunch of other roles I’ve landed myself (including advising a server migrating away from a nearly decade old codebase to Sponge). I’ve recently been working on a website for some of my friends who are fundraising for charity.
I’ve never really made any money from any of the OSS development I’ve done, amounting to a total of $30 from a BountySource I did as a one-off. Please don’t take that as a complaint though, I would be developing software OSS or otherwise - I see it as a hobby, I find it fun. Which is why I’m not longer the right person to maintain Waterfall - I no longer have need to, or find it fun - in fact merging upstream changes is a time-consuming, monotonous task :(
Though this may all sound like I’ve hated maintaining Waterfall, which certainly isn’t the case - it's just how I’ve felt as of late. Frankly, the wonderful community has kept me around for as long as I have. It’s been really nice to talk to people that I may have fallen out-of-contact with, were it not for Waterfall.
Maintaining Waterfall has been an honour, and I’m very proud that we’ve become the go-to for modded and regarded as an analogue to Paper.
And with that, my notifications are going to significantly reduce :D And finally, I’d like to thank @electronicboy for committing to maintaining Waterfall! Legend :)
Revert "selinux: fuck selinux"
Thanks to @ atndko, we can run execprog without selinux hacks. Let's not mess it up. This reverts commit 76ae9e8d196b50a7260ddcd44885c3ca742c22b3.
Signed-off-by: grislux55 jebchou.hg@gmail.com
Johnny and the Beanstalk
One evening Johnny found some funny looking beens in his grandfather's garden shed, and decided to plant one of them. Next morning, to his surprise he found an enormous beanstalk growing in his back yard. Undaunted by its size, he decided to count its leaves.
You must know that beanstalks in Byteland grow in a very special way. At the lowest (1st) level, there is exactly one stem. At any level(including the 1st), a stem can end (forming exactly one leaf), or branch into exactly two stems which grow into the next level, following the same rules.
Johnny believes he has managed to count the number of leaves at each of the levels of the beanstalk. However, you must know that before he began to count, Johnny ate one or two of the other beans he found in his grandfather's shed, and that's why he is not quite sure of his results. Please verify whether Johnny's results may possibly be correct, at least in theory.
omg (oh my god)
me soooo hoooorny me soooooo hoooooooooooooooorny me love you rrrong time
Realistic and brief version
If your wife told you "Den Kreisverkehr an der dritten Ausfahrt verlassen" you'd probably ask her if she feels OK... No German speaker would use the phrases generated by the current de_tts, at best a lawyer or a policeman would do.
A little bid annoyed by the talkative Osmand I made much of the commands shorter and nearer to real life: (i.E. "Die Entfernung beträgt 42 km, Zeit 25 Minuten" --> "42 km in 25 MInuten" , "Den Kreisverkehr an der zweiten Ausfahrt verlassen" --> "Im Kreisel zweite raus.", "In 400m rechts abbiegen" --> "In 400m rechts", "Sie überschreiten die Höchstgeschwindigkeit" --> "Zu schnell", "zirka einen Kilometer" --> "rund einen Kilometer", "Geschwindigkeitskontrolle" --> "Blitzer". ...)
Try it - you won't miss anything!
HOly shit! Entity query done! gotta testgit status holy fuck!
"11:30am. Done with breakfast. I am in a festive mood right now. Let me do some more reading, watch the ep of Mahouka, then that video by SPJ. After that I'll start work on the code generator.
11:55am. Forget Mahouka. I am too restless. Let me go for the vid by SPJ. Then I move on to the codegen. I want to get this out of the way. Only after the codegen is done can I move to actually useful things.
12:05pm. https://youtu.be/ZuNMo136QqI?t=379
It seems my notion of what predicative and impredicative means was wrong. I thought predicative was merely rank 1, but it the difference is more elaborate than that.
https://youtu.be/ZuNMo136QqI?t=1407
GHC's typechecker has 83k LOC. That is something.
12:30pm. I watched half of the video. That was enough to satisfy my curiosity about the video, but polymorphic instantiation is not something I am interesting in working on so I'll stop it here. Let me indulge just a bit more - I'll watch that damn Mahouka ep. After that, it is codegen time. I need to put some thought into the code generator. I won't be able to do it all in one day of course - it will take me some time to cache into it. But a few days should be enough. Today I will try to break the ice properly.
In order to produce heat, the most important thing is to keep the flame going. That I am trying to watch anime, but my thoughts keep straying is a good sign - it means I am more interested in programming than leisure. That kind of attitude will lead to getting things done.
12:55pm. It is time to start. This is actually the time I usually start the after noon session.
It is time for some coding pain some more. But I can deal with this. I've gone through the 1.6k LOC that is in the partial evaluator. And who knows how many thousands of lines in the previous phases.
I'll survive the next few days of this.
1:10pm. I am studying the codegen from the prototype. It is 300 and missing things like closures, unions and macros.
The one from v0.1 is a bit better at 400 LOC. That one at least has pattern matching.
1:15pm. Ok, I need to get into this. Codegen is the next phase and looking at this code, I see that it requires special taste. The first thing to do is to acclimate myself to it.
I have to desire to deal with it strongly, but not to the point that I am impatient.
1:35pm. Ok...
You start off with strong desire. Then in the face of pressure it starts pettering off. Your job is to balance the pressure and the desire to some stable level where surmounting the individual obstacles results in satisfaction. You can never swallow the whole thing all at once. Instead you need to do it one at a time.
1:45pm. Let me take a break. I am going to have to mediate on this next part for a while. I am not sure if I'll find the strength to start it today.
I need to form the goals first. Then I'll act on them. I should try imagining dealing with the top level first.
2:30pm. Done with chores. Let me try to get something going. I need to do it from the ground up.
type CodegenEnv =
{
keywords : KeywordEnv
stmts : StringBuilder
indent : int
join_points : Tagger<JoinPointKey>
types : Tagger<Ty>
}
member x.NewDefinition = {x with stmts = StringBuilder()}
member x.Statement s =
x.stmts
.Append(' ', x.indent)
.AppendLine s
|> ignore
member x.Text s = x.Statement s
member x.Indent = {x with indent=x.indent+4}Ah what the hell, let me just copy this from last time. When in doubt, that is what I should do. Since I am not inspired, I should just follow my old steps.
2:55pm. Hmmmm...
| DUnion(a,b) -> dirty <- true; push_op s Box (DUnion(f a,b)) (YUnion b)
| DNominal(a,b) -> DNominal(f a,b)3:50pm. I am still thinking about this.
Now that I have nominals, it is not at all straightforward for me to eliminate them during codegen.
I am thinking of simply leaving out the return type in functions in order to simplify things.
4:40pm. I am boring a hole through reality with my mind.
type Nominal = {|body : T; id : int; name : string|} ConsedNode // TODO: When doing incremental compilation, make the `body` field a weak reference.4:45pm. Let me go to bed bed for a bit. This brainstorming session is really taking me by a storm. I think I have it, but I want a bit more to think.
4:50pm. Since it is this late, I might as well spend the next hour thinking and then call it a day. No point is doing a programming run this late.
Unless I have anything else I want to write, I'll make this the last entry for the day."
"5:35pm. I've settled on the design. There is no way around it. By necessity, the code generator will need to have a dependency on the partial evaluator. The way I will get around the problem of having nominals is by taking ty_to_data and returning it as a function along with the join point dictionaries.
let data_free_vars call_data = // ...
let data_term_vars call_data = // ...Thankfully these two are globals.
5:45pm. Let me pull apply outside of term.
let peval (env : TopEnv) s x =Now I can get rid of this s argument on the outermost level.
5:50pm.
let s : LangEnv = {
trace = []
seq = ResizeArray()
cse = [Dictionary(HashIdentity.Structural)]
i = ref 0
env_global_type = [||]
env_global_term = [||]
env_stack_type = [||]
env_stack_term = [||]
}
let ty_to_data x = ty_to_data {s with i = ref 0} x
term_scope s x, {|method=join_point_method; closure=join_point_closure; ty_to_data=ty_to_data|}Actually, nevermind. I decided not to pull the apply. Instead I will just assume that the expression passed into peval is main (). That is main apply by ().
cse = []Let me make the cse this. This is generally a bad idea, but in this specific situation it is a great idea.
seq = nullAlso let me make the seq null.
let s : LangEnv = {
trace = []
seq = null
cse = []
i = ref 0
env_global_type = [||]
env_global_term = [||]
env_stack_type = [||]
env_stack_term = [||]
}Now if this gets used in any unanticipated way, I'll get a null exception right away.
Yeah, this is what the starting environment should be. As a matter of fact, I can make the arrays null as well.
let s : LangEnv = {
trace = []
seq = null
cse = []
i = ref 0
env_global_type = null
env_global_term = null
env_stack_type = null
env_stack_term = null
}Now it is really illustrative what I am expecting the expression passed into peval to require.
6pm. No way around it. I might have bragged what good grasp on the codegen I have, but v0.2 is different from the previous versions. Now that nominals exist, I need a way of figuring out what free variables lie inside them and I cannot do that without evaluating them.
I am going to have too loosed the requirements on what kind of information I am capable of transmiting between the passes. Alternatively, I supposed I could always story this information inside the join point keys. But then I will have a problem as to what to do with layout types.
Just being able to turn regular Types into Data is the easiest solution to the broad spectrum of problems.
The disadvantage now is that there is a non trivial dependency between the partial evaluator and the code generator, but unless there is a programming error this won't be a problem. The function I am passing should act like Ty -> Data for all intents and purposes.
6:10pm. Mmmmhhhh...I am feeling it.
Drilling into a side problem is an excellent of building motivation to tackle the main one. I think I have everything I need to get started on this tomorrow.
I am going to get a good chunk of the code generator out of the way tomorrow. There is no reason why I should not finish it over the next few days. I need to maintain this work attitude.
After that comes tying up the phases by making the server, and then testing. I'll finally be able to produce F# code from Spiral's.
That will be the start of everything. That is when the next phase will come. By the end of the month I will be able to seriously start thinking about getting my hands on neurochips. I've been putting thought into how to sell out properly and I'll be able to see how that will work out.
Let me stop here from the day. It is time to unwind. I've done my brainstorming and now it is time to put that aside. If I have to do more thinking, I should leave it for during the work day tomorrow."
KAFA-9234: Added Nullability Annotations to Admin
This introduces a new compile-only dependency on JetBrains Java Annotations. I decided to go for this particular dependency because it does not introduce any visible change to our users, not does it introduce any additional overhead to the build process. If we get an annotation wrong, nothing bad happens because it is totally up to the code to actually validate things.
One downside (some might say upside) is that absolutely everything must be annotated. I personally think this is a good thing because it forces people to actually think about null, same is the case in Kotlin where I also have to define whether null is permitted or not absolutely everywhere. Kotlin is also the main reason why I am interested in this, and also why I am interested in having this everywhere.
I was not able to test all possible NPE situations because some require the call to actually be executed. For those where I was able to proof that null is invalid we could think about adding Objects.requireNonNull guards right at the beginning. For all others it simple, if we proof it we can add the guards too. This might be wasteful for collections (especially if those collections contain collections). A possible way out here is to use assert and life with the fact that some NPEs are thrown much later and will make it hard to find the source. This, sadly, is not Kotlin, so there is no easy way for this.
This PR also contains a bug fix. Admin.describeUserScramCredentials() (without any arguments) was passing null to Admin.describeUserScramCredentials(List<String>) which is not permitted and leads to an NPE. Maybe there is another ticket for this, or nobody ever called this method (which would raise the question why it exists). In any event, the documentation of both Admin.describeUserScramCredentials(List<String>) and Admin.describeUserScramCredentials(List<String>, DescribeUserScramCredentialsOptions) say in their doc that users may be null and that all users’ credentials are fetched if that is the case (same for an empty list), however, in KafkaAdminClient we have an unconditional call on users.stream() that leads to said NPE. I removed the mention of null, not sure what the stance is regarding doc changes and their relation to breaking changes. This effectively just aligns the doc with the real code and the behavior does not change, but maybe we actually want the null support here, in that case we would need to change the code. Let me know what you think.
I think that it would be best to remove this implicit behavior (which effectively is just a doc change) and add an explicit method to the interface that is called describeAllUserScramCredentials.
PS: I am willing to continue this endeavour if it is decided to accept this PR (also if we decide to opt for another library that provides the ability to add null checks, e.g. Checker Framework, Lombok), simply because the experience in Kotlin with Kafka and the missing nullability information is horrid.
PPS: The JetBrains annotations contain additional annotations like @Unmodifiable, @ApiStatus.Internal, @RegExp, or @Language that ease development work tremendously. I think it would be more than worthwhile to start using them as well if we decide to go with these annotations.
final changes before my good friend stasia tests it and tells me i'm a fucking idiot