We load ROSAT Vela data (from the survey) and generate a 3D cube with pi as the 3rd axis. (You can flip between the cube and the original with the > or < keys.) With a bin width of 128 (i.e. cube slices of pi=1:128 and pi=129:256), Vela Jr pops out as you switch between slices (using Next or Blink in the FITS data cube plugin.)
If you change the bin width to create a cube with a different 3rd dimension, it is still possible to see Vela Jr, but less obvious as the slices get narrower.
JS9 uses high-level C routines filterTableToImage() and getImageToArray() to generate a 3D cube and flip between slices. We should be able to do this automatically, i.e. using algorithm(s) to explore different sets of slices, without needing to evaluate the results by eye.
|
|
bin width:
Refererence:
https://www.nature.com/articles/24103.pdf
containing this graphic:
|


--- layout: post title: Google Wishes Me a Happy Birthday categories: [] tags: - birthday - google status: publish type: post published: true meta: _original_post_id: '' _original_import_author: John Duprey author: ---


{% include 'entities/pageheader.html' %} {% if error_message %}
{{ error_message }}
The Underground Theater Code of Conduct has recently changed. Please review it and check "I Agree" below to accept the terms.
I Agree


The rise of jobstoppers: should face tattoos be banned?
by Guardian StaffTattoo artists want to raise the legal age limit for facial inkings from 18 to 21, as they could harm young people’s career prospects
Name: Face tattoos.
Age: They were outlawed by the Roman emperor Constantine in AD316, so older than that.
Appearance: extremely noticeable.
Obviously.  Or if you ever desired gainful employment.
Why is that? They are known in the tattoo trade as “jobstoppers”. A 2018 survey found that six in 10 employers would be “substantially” less likely to hire someone with a face tattoo.
That was then. This is now. In the meantime, face tattoos have become more popular, thanks to Instagram and inked celebrities including Justin Bieber and Little Mix’s Jesy Nelson. “I can’t go a week without a young person coming into our studio asking for a tattoo on their neck, face, or hands,” says Lee Clements of the British Tattoo Artist Federation (BTAF).
That’s because face tattoos are cool. You know they don’t come off, right?
Of course. So what? So what happens when you grow up and apply for a job in public relations?
It will never happen. Anyway, by then having flames tattooed above each eyebrow will probably be completely socially acceptable. But what if it isn’t?
Dunno. This is precisely why the BTAF is proposing to change the legal age for face tattoos.
What is it now? If you are 18, you can legally get a tattoo anywhere on your body. They want to raise it to 21 for anything on the face, neck or hands.
That’s so unfair. Having tats is my right!
Because Lil Xan has them! If Lil Xan robbed a bank, would you do that, too?
I think so. That’s why we need the law changed.
I don’t care about your laws, mate, or what the average Daily Mail reader thinks. They think people with face tattoos should be denied benefit payments.
Really? “If you intentionally make yourself unemployable by doing this – no benefits for you,” said one, commenting on the news.
Well. That is slightly concerning. “Anyone that gets a tattoo on their face which does prevent them from working should have all benefits permanently stopped,” said another.
I don’t see that sentiment gaining wider currency, do you? “Ink on faces should be instant disqualification from access to benefits,” said a third.
Huh. I’m just going to text my mum. OK.
Do say: “It says ‘LIB DEMS’, but I was only getting tattooed tactically.”
Don’t say: “That’s my CV, right there on my left cheek. Ignore the MySpace address.”


If you like this solution, you can also check my personal wesbite, Acid.JS Web.UI, my blog or follow me on Twitter.
Love that? Please, donate!
This solution works with all modern browsers and Internet Explorer 9+. If you are interested in purchasing a JavaScript enabler for IE8 for the CSS3 Treeview, please, click here.


Sign to Access Vault
You must hold the vault asset in your Freeport Collection
Dandelion Jeb
Address:
Address
Sign message below:
Message
Signature:
Signature
Enter
Freeport Vault


2 Samuel 17:15
Then said Hushai unto Zadok and to Abiathar the priests, Thus and thus did Ahithophel counsel Absalom and the elders of Israel; and thus and thus have I counseled.


I really like using command line arguments. I think that it is a flexible way to interact with and configure my games/engine.
It is for example easier to just add a --log-verbose=resource
to set all logging in the “resource”-domain to verbose or
--memory-enable-stacktrace=render
to enable save of stacktraces for all allocations done in the “render”-allocator than to
edit some config-file somewhere. At least for things such as the ones mentioned above, that is only set once in a while.
Note: It’s also a simple replacement for config-files, but that is something for a later blog-post ;)
However it seems like there’s always one problem, how to register supported command-line arguments to show –help and check that arguments are correctly specified? In this blog-post I’ll outline a solution that I have found works really well for me. It has its drawbacks but that is usually the case with any solution to any problem ;)
What do I want to achieve?
Let’s make a quick list over what I want from my system.
- Different systems to be able to register their supported command line arguments in a simple fashion.
- Automatic –help generation ( I always forget what flags are there etc, –help to the rescue )
- Systems that register args should be able to assume that all flags are valid when they get the args.
How I do it
First of all I let all systems parse their own argc/argv, in other words I just pass each system a reference to argc/argv. This is done in different ways, but usually something like this:
log_ctx_t logger = log_ctx_create( /*... some param ... */, argc, argv );
or this:
renderer_create_info create_info;
// ... other params ...
create_info.argc = argc;
create_info.argv = argv;
renderer_t r = renderer_create(&create_info);
The systems get access to a const argc/argv and its their job to parse them by them self. For this I use ( shameless self-promotion comming up )
this getopt-parser https://github.com/wc-duck/getopt. But how does that tie in with our earlier demands on the “system”.
Well, lets use some thing that some one consider the c++-equivalent of swearing in church, global constructors! Lets introduce
a simple helper-class and macro GETOPT_ARGS_REGISTER()
.
struct __getopt_args_register
{
__getopt_args_register( const char* t, const getopt_option_t* opt )
: next( first )
, options_title( t )
, opts( opt )
{
first = this;
}
static __getopt_args_register* first;
__getopt_args_register* next;
const char* options_title;
const getopt_option_t* opts;
};
#define GETOPT_ARGS_REGISTER( options_title, options ) \
static __getopt_args_register JOIN_MACRO_TOKENS( __getopt_reg, __LINE__ )( options_title, options )
And we use this as follows
static getopt_option_t options_list[] = {
{ "log-info", 0x0, GETOPT_OPTION_TYPE_OPTIONAL, 0x0, 'i', "set log-level info, globally if no domain is specified.", "DOMAIN" },
{ "log-error", 0x0, GETOPT_OPTION_TYPE_OPTIONAL, 0x0, 'e', "set log-level error, globally if no domain is specified.", "DOMAIN" },
{ "log-warning", 0x0, GETOPT_OPTION_TYPE_OPTIONAL, 0x0, 'w', "set log-level warning, globally if no domain is specified", "DOMAIN" },
{ "log-verbose", 'v', GETOPT_OPTION_TYPE_OPTIONAL, 0x0, 'v', "set log-level verbose, globally if no domain is specified", "DOMAIN" },
{ "log-callstack", 0x0, GETOPT_OPTION_TYPE_OPTIONAL, 0x0, 'c', "log callstacks together with messages, globally if no domain is specified", "DOMAIN" },
{ "log-domains", 0x0, GETOPT_OPTION_TYPE_NO_ARG, 0x0, 'd', "log all available domains as they are discovered." },
GETOPT_OPTIONS_END
};
GETOPT_ARGS_REGISTER( "log", options_list );
What the above macro basically does is on old trick, building an global linked list of __getopt_args_register when running global constructors that
can be accessed via __getopt_args_register::first
.
When we have this info it is an easy thing to just loop over all registered args and do the error checking and –help generation etc without the systems
having to know about it. I usually do this as a really early part of int main( int argc, const char** argv )
.
Also notice that the registered options is the same type that is used by the getopt-library so that the same setup can be used during arg-parse. Keeping the
registered args defined in one place and one place only.
One of the things I like most with this is that the registering is done link-time, so linking to a static library, in my case render, debug or vfs ( to mention a few ) auto-registers its options. So if a lib is not used/linked, no options is registered.
Drawbacks
Well there are some of course. This will not work well together will DLL:s since the main .exe and the .dll:s will get their own instance of
__getopt_args_register::first
and the ones in the dll will not be accessible from the exe. It could be solved by “pulling out” __getopt_args_register::first
from each DLL and manually “link” them together but that is not something I have done or have had any need for.
Also there is the problem of colliding flag-names and that is best solved by just not sharing flag-names, I prefix my flags by system. In some cases you might even want colliding flag-names where you have flags that should be used by multiple systems. Not sure if it is a good idea, but it is definitely something that can be done.
Conclusion
This is a technique that has served me well for this purpose and the “global linked list created with global constructors” could be a useful tool in your toolbox when writing c++. It need to be used restrictively, but at least for this purpose it has not been any problems for me.


First Name
Last Name
Age
Gender
Male
Female
Location
Save
First Name
Last Name
Age
Gender
Location
User :
got aadded Successfully


--- layout: post title: Shortlisted for the Bateson Prize! date: 2009-09-08 21:32:45.000000000 -07:00 categories: - general news tags: [] status: publish type: post published: true meta: _edit_last: '1' author: login: ckelty email<EMAIL_ADDRESS>display_name: ckelty first_name: Christopher last_name: Kelty excerpt: !ruby/object:Hpricot::Doc options: {} ---
Two Bits was one of four shortlisted books.
The Society for Cultural Anthropology's 1st annual Gregory Bateson prize was given to Barray Saunder's CT Suite: The Work of Diagnosis in the Age of Noninvasive Cutting. Two Bits was shortlisted alongside some other great books. More here...


Cameron-Daniel, P.C.
About
Services
Attorneys
Contact
/h2>
Dan Griffiths
Attorney
Bruce McLaughlin
Attorney
Send us a Message


The Story
Not 'satisfied' with the blah high lifestyle surroundings supplied as the base retirement high lifestyle, Sherlocke went exploring for alternatives in the area. He has an interest knowledge skill for Fictional Detectives. He knows what the 'Bat Cave' is. For himself, he wanted an 'Owl’s Nest' (burrowing owl, Owl mentor sprite SM182 :) )
As a psychic detective, knowing what is around can be very useful. The last spell learned, shortly after being 'retired' was Spatial Sense (SM168). Some straight forward research located some potential (lifestyle) compatible areas that also had the potential for reasonable large underground cave systems. There were even some hints about caves that had been used for smuggling in past centuries. With the aid of a Spirit of Earth, and the spatial sense, he went exploring. It took some time, but a few candidates were found. Nothing 'ready made', but with some (spirit) work, things could be connected. One location stood out. One of the caves aligned with the juncture of a couple of minor lei lines. The location had some disadvantages too though. The residence that would allow access was in a corp gated community with cameras everywhere. Since he has to 'be' Holmes, Sam figures he can live with that. It will just be an extra reminder that his whole public life is 'in costume'.
Some serious negotiations later, with assistance from Mrs Watson (and probably her bosses), he (actually they) moved in and he got to work. Using spirits, the actual physical access modifications were not that difficult. Time consuming yes. While that was going on, he had some more research and negotiations to do. The mana at the junction was not quite 'right'. It interfered more than helped his magic use. He had to locate a geomancer chaos mage willing to put in some time to tune it before he could use it, and do the sculpting needed to keep it compatible.
Now though, he has a private space, where he can get away from everyone, to work on his magic, with plenty of extra space for any storage or other workspace for the purely detective / forensics work.
discussion: The "Owl’s Nest" does not *have* to be secret. It is not advertised, and the extent of the space is definitely downplayed. Any 'escape tunnel' aspect of course is not public. With the story, adding escape tunnel made sense. Though it did complicate balancing the qualities. Having a secret entrance/exit is an advantage for any shadow work, whether as a Fixer or detective. If using the cave system story, it does not make sense to NOT include the escape tunnel, and that environment seems to require an astral privacy shield.
Other variation
Looking for a place that was big enough for the magical lodge, Sherlocke found a warehouse on the edge of an old (now abandoned) light industrial area. Someone had taken the time to convert and renovate much of the building into suites of apartments, with all of the modern amenities and security. It was not quite the nicest area, but almost everything else seemed made to order. A secure high end apartment, with a large enough space for the lodge on an uncoverted lower level. A bit of additional renovations, and that area could be accessed directly from the bottom level of the suite.
discussion: I like the cave with Owl's nest. The warehouse works too, and could still add the Escape Tunnel there. Doing the renovations to get direct access could have discovered / added the discrete entrance / exit from the building. Just harder to justify Corporate-Owned to balance things out. The final variation on the lifestyle page looks interesting. Possibly over-complex setup, but it does fit well with the emulated Holmes lifestyle.
The customized dragonfly drone had the exotic meelee weapon 'claws' replaced by a squirt gun. The only way I could find to enter that in chummer, was a weapon mount and the Super Squirt. The range is only supposed to be about a meter, and the clip is probably ony a few shots. On the same order as a holdout. Maybe 5 shots.


Consent
We are a group of researchers from the University of Minnesota. We are conducting an academic study about recommending movies. In the survey below, you will be asked to identify key features of a movie.
Contact Information. This research (1411E56001) is approved by the Institutional Review Board at the University of Minnesota. You can contact the requester by emailing<EMAIL_ADDRESS>If you have further concerns, you can contact the Institutional Review Board by emailing<EMAIL_ADDRESS>or calling<PHONE_NUMBER>.
Privacy The records of this study will be kept private. In any sort of report we might publish, we will not include any information that will make it possible to identify a subject. Research records will be stored securely and only researchers will have access to the records.
Instructions
Please look at the movie shown below and answer the questions below. It does not matter whether or not you have watched the movie; use your best judgment.
Note:
- Some questions have verifiable answers that we will check before accepting your HIT.
{{ movieTitle }}
{{ movieDescription }}
Imagine that you are recommending "{{movieTitle}}" to a friend who is interested in "{{clusters[clusterIdx]['cluster_label']}}" (further explained by keywords below). Which of the following sentences would you say? In addition, please count the number of adjectives in each sentence and fill that in the text fields below.
Keywords: {{clusters[clusterIdx]['tag'].join(', ')}}
| Best | # Adjectives | Quote |
|---|---|---|
| {{ review }} | ||
| None of the above is good enough |


Run your mouse over the text below to see the effect.
Tiger, tiger, burning
bright,
In the forest of
the night,
What immortal hand
or eye
Could frame thy fearful
symmetry?
In what distant deeps
or skies
Burnt the fire of
thine eyes?
On what wings dare
he aspire?

And what shoulder,
and what art,
Could twist the sinews
of thy heart?
When thy heart began
to beat,
What dread hand forged
thy dread feet?
What the hammer?
What the chain?
In what furnace was
thy brain?
What the anvil? What
dread grasp
Dared its deadly
terrors clasp?
When the stars threw
down their spears
And watered heaven
with their tears,
Did He smile his
work to see?
Did He who made the
lamb make thee?

I have to clean your
litter tray.
with apologies to William Blake


Mono is an cross-platform and open source implementation of the .NET framework that was started independently in 2001. The technology was originally developed by Ximian, which was acquired by Novell, then at Novell, then at Xamarin and now Microsoft.
Mono provides a complete SDK (compiler, runtimes, libraries) to develop .NET applications on a wide range of platforms. It is most commonly used as a .NET runtime that supports the .NET desktop API profile, as well as an embeddable runtime that is used to power mobile platforms (Xamarin.iOS, Xamarin.Android, Xamarin.tvOS, Xamarin.Mac, Xamarin.watchOS) and gaming consoles.
Mono is part of the .NET Foundation and Microsoft supports it as part of the Xamarin commercial offerings. Additionally, the Mono project has an active and enthusiastic community.


How does Unwalled.Garden work?
Unwalled.Garden is a kind of “Souped up RSS.” Every user has a website, they publish their content as files, and they subscribe to each others’ sites.
While RSS was primarily for blogging, Unwalled.Garden includes data types for many kinds of use-cases. These data types are spread across many JSON files which have pre-defined schemas.
The schemas are simple, obvious, and syntax-free. A “status” record looks like this:
{
"type": "unwalled.garden/status",
"body": "Hello, world!",
"createdAt": "2019-05-21T21:27:45.471Z"
}
We identify the types using URLs such as:
All files are placed at predefined paths. An example site might look like this:
| URL | Type |
|---|---|
dat://bob.com |
Person |
dat://bob.com/.data |
Data directory |
dat://bob.com/.data/statuses/hello.json |
Status |
dat://bob.com/.data/reactions/1.json |
Reaction |
dat://bob.com/.data/comments/1.json |
Comment |
This site identifies as a Person and it includes a Status, Reaction, and Comment. A reader will crawl the website looking for these files to sync into its local database.
Unwalled.Garden is built for the Dat protocol. Read an introduction primer here.


This port lies about 50nm east of Oran on the eastern side of the Gulf of Arzew.
Position 35°56′N, 0°5′E.
Call the Port Authorities on VHF channel 16 or 14 on approach. They will visit the boat at the entrance to complete formalities. Decline to give any 'gifts'.
Last updated August 2014.
For water and fuel, ask the police/coastguard.
When leaving the port, you will be escorted by a policemen in civilian clothes who will help you to find what you need.
A taxi to the town costs about 60 to 80dh.
Last updated August 2014.


Lily He, Tenzin Dasel, Jasmyne Jean Remy, Jennifer Lin
The website allows users to create a personalized profile and then finds a with Doctors based on factors such as the user's location, insurance policy and their conditions.
We hope to benefit the community by making finding doctors much easier for patients in case of emergency.


Have any questions or need assistance in assessing your logistics needs? Send us a message through our contact form below or give us a call at US:<PHONE_NUMBER>. If you're ready to receive a preliminary quote, fill out our online quote form.
Hours
Mon-Sat: 9:00AM – 5:00PM
Phones
US:<PHONE_NUMBER>Emails
operations@trinityshipping.com


{% include 'fragments/js/google_analytics.html' with ga_tracking_id=False ga_domain=False ga_type='universal' %} {% include 'fragments/js/mixpanel.html' with mixpanel_code=False %} {% include 'fragments/js/facebook.html' %}


Food/Service Industry
Comparisons of Occupation Data in the Food/Service Industry
Use the interactive chart below to explore the dataset
Year:


There are four Athena (or Minerva, no one can decide on the name!) clusters around campus. Each one requires entering a certain passcode on a numerical keypad to get in, and the passcode itself is always given to you by a person nearby. However, if we try to input the digits, different digits (or even non-digits in one case) show up on the 7-segment display. We need to figure out how the keypads actually operate in order to enter the desired passcode.
This is what the keypad looks like:
This is the first cluster to be unlocked. Outside the door is a person who tells us that the code is 8675309, that the keypads have recently gotten difficult to use, and that you can press the asterisk to start over.
For this keypad, the first digit you enter always shows up as intended, but subsequent digits are often totally wrong. After some experimentation, we can see that if you first input the digit X and then input Y, the actual digit that shows up is the units digit of X+Y (so if you type in “75”, then “72” actually shows up because 2 is the units digit of 7+5=12). It turns out that whenever you enter a digit, the actual digit that appears is the units digit of the sum of all current displayed digits and your input digit.
So, in order to get 8675309 to show up on a keypad, we must first enter 8, and then another 8 (because 8+8=16), then 3 (because 8+6+3=17), and so on. The full input is “8834710”.
The code for this cluster is 5726418.
For this keypad, each digit performs a certain transformation on the current number and then adds itself to the end. Perhaps one of the clearest examples of this is 8, which reverses the number (and then appends an 8 at the end), so if the current code is “12345” and you input 8, the result is “543218”. With some experimentation, we can figure out what each digit does:
| 0 | Do nothing (then add a 0 to the end) |
| 1 | Delete the first digit (then add a 1 to the end) |
| 2 | Replace each digit X with 9-X (then add a 2 to the end) |
| 3 | Add 1 to every digit, with 9 turning into 0 (then add a 3 to the end) |
| 4 | If there are any consecutive equal digits, remove all but one of them (then add a 4 to the end). For example, “334555” would turn into “3454”. |
| 5 | Move the first digit to the end (then add a 5 to the end) |
| 6 | Change every digit to a 6 (then add a 6 to the end) |
| 7 | Replace the current number with the count of lit segments on the seven-segment display (then add a 7 to the end). For example “888” would turn into “217” because “8” has all seven lit segments, so the total number of lit segments is 8*3=21 |
| 8 | Reverse the number (then add an 8 to the end) |
| 9 | Delete the last digit (then add a 9 to the end). This is the same as replacing the last digit with a 9. |
In order to input 5726418, we can go backwards from the end. Because the last digit of this code is 8, the last digit we type in also has to be 8 (because every number adds itself to the end), so the code right before that has to be 146275. Then, the second-to-last digit we type in has to be 5, and the code right before that has to be 71462. Then we must have typed a 2, and the code before that has to be 2853. And then the code before typing in a 3 has to be 174.
From here we have a little more freedom, because the code before typing in the 4 could be any of “17”, “117”, “177”, “1177”, etc. The one tricky thing is that “17” is actually impossible to get, because there is no digit with only 1 lit segment. There are many possible ways to achieve this: for example, “84” has 11 lit segments, so one potential solution is “84743258”.
We are told that the code is PEACHES, in upper-case.
For this keypad, inputting a digit toggles all of the corresponding segments of that digit in the display. So, for example, inputting 0 will make the display read 0, and inputting a 0 again turns the display empty again because it toggles all the same segments. Inputting 0, then 1, makes the display a capital “C”, because the two rightmost segments (the ones that make up “1”) are toggled off in the “0”. Equivalently, the segments are XORed with the existing segments.
The “active” digit can be shifted to the right by pressing the pound symbol (i.e. at the beginning all inputted digits only affect the first slot on the display, and then if you press pound, it will affect the second slot, and so on).
We can determine how to make each letter in “PEACHES” either by trial and error, or more systematically by coming up with a sequence of digits that achieves each individual segment. For example, you can immediately get the middle segment with “80”, the bottom-left segment with “89”, and the top-right segment with “86”. Then you can get the top-left segment by noting that “83” gives you both the bottom-left and top-left segments, but we already know that “89” gives just the bottom-left segment, so we can get just the top-left segment with “8389” (or equivalently, just “39”).
One possible solution is “013678#18#037#01#489#18#5”.
The code for this cluster is 201608.
Playing around, we notice that inputs generally happen in pairs: if we input two digits that sum to less than 10 then it will display their sum, and if we continue typing in pairs of digits that sum to less than 10, the previous pair sums get pushed to the left, showing at most 3 at a time. Here is a sample sequence of inputs:
| Input | Result |
|---|---|
| 4 | 04 |
| 3 | 07 |
| 4 | 0704 |
| 1 | 0705 |
| 8 | 070508 |
| 1 | 070509 |
| 2 | 050902 |
| 6 | 050908 |
Additionally, if the pair of digits sums to greater than 10, then the code immediately resets to blank, suggesting that’s not allowed for some reason. However, if the sum is exactly 10, the behavior is a little weird: it will display 10, but upon entering the next digit, that digit also gets added to the 10. For example, if you type in 64 the display will say “10”, and then typing 7 will result in “1707” (and then typing 1 will give “1708”).
Finally, if we press the pound sign, the display will also say “10”, but the next two inputted digits also get added to it.
From this information, we can realize that this is a game of bowling, where inputting digits counts as hitting that many pins, and the pound sign is a strike. The display shows the point values of each of three consecutive frames, which is why getting a spare or strike causes future inputs to get added to the 10.
To achieve 201608, we note that the second frame (16) can only be from a spare, and in particular we need 6+2 points in the third frame, so that the 6 is added to the second frame. This implies that the first frame (20) has to be a strike, where you get 10 points plus 10 more for the spare on the second frame. One sequence of inputs representing this is “#4662”, but anything with a spare on the second frame works.


Technical architecture:
This application uses following javascript libraries:
Open source code:
This application was created and developed by Patrick Brockmann (CEA - LSCE), with coding contributions from Cathy Nangini (CNRS - LSCE). The source code is available at: http://github.com/PBrockmann/ClimateProxiesFinder
Credits:
The baselayer tiles are provided by the ArcGis Online service
http://services.arcgisonline.com/ArcGIS/rest/services/Ocean_Basemap/MapServer
Shopping cart icons from Christmas&Shop icons by Artyom Khamitov License: CC 3.0
Known issues:


{%extends "adm/admin_base.html" %} {%load humanize%} {%block title%}Refunds{%endblock%} {%block layoutblock %}
| Num | Invoice | Registered | Issued | Completed | Provider | Reason |
|---|---|---|---|---|---|---|
| {{refund.id}} | #{{refund.invoice_id}} | {{refund.registered|default:""}} | {{refund.issued|default:""}} | {{refund.completed|default:""}} | {{refund.invoice.paidusing.internaldescription}} | {{refund.reason}} |


{% extends "layout.html" %} {% block content %}
An unexpected condition was encountered. Our service team has been dispatched to bring it back online.
{{trace}}


13
1 This is the third time I am coming to you to deal with these matters. The principle in dealing with these issues is that every accusation against another must be based on the testimony of two or three persons, not just one.
2 When I was there on the second visit I said to those who had sinned and who being charged before the church, and to the entire church, and I will say it again: I will not overlook these charges.
3 I tell you this because you are looking for proof that Christ is speaking through me. He is not weak in dealing with you; instead, he is working in you by his great power.
4 We learn from Christ's example, because they crucified him when he was weak, yet God has made him alive again. And we, too, are weak as we live and follow his example, but with him, God will strengthen us as we talk with you about these sins that some of you have committed.
5 Each of you must examine how he lives; you must look for evidence that you trust in how God loves you and has mercy on you.  He lives in every one of you, unless, of course, you fail this test.
6 And I hope that you will find that Christ lives in us, too.
7 Now we pray to God that you may not do anything that is wrong. We pray for this, not because we want to seem better than you by passing that test. Instead, we want you to know and do the right things. Even if we seem to have failed, we want you to succeed.
8 The truth controls what we do; we cannot do anything against the truth.
9 We have joy when we are weak and you are strong. We pray that you may always trust and obey God completely.
10 I am away from you now as I write this to you. When I come to you, I do not have to deal harshly with you. Because the Lord made me an apostle, I prefer to encourage you and not to make you weaker.
11 The last thing, brothers and sisters, is this: Rejoice! Act and behave better than you have been acting, and allow the Lord to give you courage. Agree with each other and live in peace together. If you do these things, God, who loves you and brings you peace, will be with you.
12 Welcome each other in a way that tells everybody how much you love each other.
13 All of us here, whom God has set apart for himself, greet you.
14 May the Lord Jesus Christ act kindly toward you, may God love you, and may the Holy Spirit be with you all.


AP Top Sports News at 3:28 a.m. EST
by EndPlayNFL ICYMI: ‘Sell the team!' chants at latest Skins debacle
On weekend of blowouts, Broncos bow out
Gurley, Brown help Rams ground out 17-7 win over Bears
Edelman's TD pass leads Patriots over Eagles 17-10
Ravens harass Watson, beat Texans 41-7 for 6th straight win
Kyle Busch leads Gibbs trio to win 2nd NASCAR championship
Steven Holcomb's Olympic legacy to grow, for a final time
Alabama star Tua Tagovailoa set for hip surgery in Houston
AP Top 25: Georgia edges past Alabama to No. 4; OU up to 8
Vikings overcome 20-0 deficit at half to beat Broncos 27-23


Module: ActiveSupport::Callbacks::ClassMethods
| Relationships & Source Files | |
| Defined in: | activesupport/lib/active_support/callbacks.rb |
Instance Method Summary
-
#define_callbacks(*names)
Define sets of events in the object life cycle that support callbacks.
-
#reset_callbacks(name)
Remove all set callbacks for the given event.
-
#set_callback(name, *filter_list, &block)
Install a callback for the given event.
-
#skip_callback(name, *filter_list, &block)
Skip a previously set callback.
Instance Method Details
#define_callbacks(*names)
Define sets of events in the object life cycle that support callbacks.
define_callbacks :validate
define_callbacks :initialize, :save, :destroy
Options
-
:terminator
- Determines when a before filter will halt the callback chain, preventing following before and around callbacks from being called and the event from being triggered. This should be a lambda to be executed. The current object and the result lambda of the callback will be provided to the terminator lambda.define_callbacks :validate, terminator: ->(target, result_lambda) { result_lambda.call == false }
In this example, if any before validate callbacks returns
false
, any successive before and around callback is not executed.The default terminator halts the chain when a callback throws
:abort
. -
:skip_after_callbacks_if_terminated
- Determines if after callbacks should be terminated by the:terminator
option. By default after callbacks are executed no matter if callback chain was terminated or not. This option has no effect if:terminator
option is set tonil
. -
:scope
- Indicates which methods should be executed when an object is used as a callback.class Audit def before(caller) puts 'Audit: before is called' end def before_save(caller) puts 'Audit: before_save is called' end end class Account include ActiveSupport::Callbacks define_callbacks :save set_callback :save, :before, Audit.new def save run_callbacks :save do puts 'save in main' end end end
In the above case whenever you save an account the method
Audit#before
will be called. On the other handdefine_callbacks :save, scope: [:kind, :name]
would trigger
Audit#before_save
instead. That’s constructed by calling#{kind}_#{name}
on the given instance. In this case “kind” is “before” and “name” is “save”. In this context:kind
and:name
have special meanings::kind
refers to the kind of callback (before/after/around) and:name
refers to the method on which callbacks are being defined.A declaration like
define_callbacks :save, scope: [:name]
would call
Audit#save
.
Notes
names
passed to define_callbacks
must not end with !
, ?
or =
.
Calling define_callbacks
multiple times with the same names
will overwrite previous callbacks registered with #set_callback.
# File 'activesupport/lib/active_support/callbacks.rb', line 812
def define_callbacks(*names) = names. names.each do |name| name = name.to_sym ([self] + ActiveSupport::DescendantsTracker.descendants(self)).each do |target| target.set_callbacks name, CallbackChain.new(name, ) end module_eval <<-RUBY, __FILE__, __LINE__ + 1 def _run_#{name}_callbacks(&block) run_callbacks #{name.inspect}, &block end def self._#{name}_callbacks get_callbacks(#{name.inspect}) end def self._#{name}_callbacks=(value) set_callbacks(#{name.inspect}, value) end def _#{name}_callbacks __callbacks[#{name.inspect}] end RUBY end end
#reset_callbacks(name)
Remove all set callbacks for the given event.
# File 'activesupport/lib/active_support/callbacks.rb', line 722
def reset_callbacks(name) callbacks = get_callbacks name ActiveSupport::DescendantsTracker.descendants(self).each do |target| chain = target.get_callbacks(name).dup callbacks.each { |c| chain.delete(c) } target.set_callbacks name, chain end set_callbacks(name, callbacks.dup.clear) end
#set_callback(name, *filter_list, &block)
Install a callback for the given event.
set_callback :save, :before, :before_method
set_callback :save, :after, :after_method, if: :condition
set_callback :save, :around, ->(r, block) { stuff; result = block.call; stuff }
The second argument indicates whether the callback is to be run :before
, :after
, or :around
the event. If omitted, :before
is assumed. This means the first example above can also be written as:
set_callback :save, :before_method
The callback can be specified as a symbol naming an instance method; as a proc, lambda, or block; or as an object that responds to a certain method determined by the :scope
argument to #define_callbacks.
If a proc, lambda, or block is given, its body is evaluated in the context of the current object. It can also optionally accept the current object as an argument.
Before and around callbacks are called in the order that they are set; after callbacks are called in the reverse order.
Around callbacks can access the return value from the event, if it wasn’t halted, from the yield
call.
Options
-
:if
- A symbol or an array of symbols, each naming an instance method or a proc; the callback will be called only when they all return a true value.If a proc is given, its body is evaluated in the context of the current object. It can also optionally accept the current object as an argument.
-
:unless
- A symbol or an array of symbols, each naming an instance method or a proc; the callback will be called only when they all return a false value.If a proc is given, its body is evaluated in the context of the current object. It can also optionally accept the current object as an argument.
-
:prepend
- Iftrue
, the callback will be prepended to the existing chain rather than appended.
# File 'activesupport/lib/active_support/callbacks.rb', line 673
def set_callback(name, *filter_list, &block) type, filters, = normalize_callback_params(filter_list, block) self_chain = get_callbacks name mapped = filters.map do |filter| Callback.build(self_chain, filter, type, ) end __update_callbacks(name) do |target, chain| [:prepend] ? chain.prepend(*mapped) : chain.append(*mapped) target.set_callbacks name, chain end end
#skip_callback(name, *filter_list, &block)
Skip a previously set callback. Like #set_callback, :if
or :unless
options may be passed in order to control when the callback is skipped.
class Writer < Person
skip_callback :validate, :before, :check_membership, if: -> { age > 18 }
end
An ArgumentError
will be raised if the callback has not already been set (unless the :raise
option is set to false
).
# File 'activesupport/lib/active_support/callbacks.rb', line 697
def skip_callback(name, *filter_list, &block) type, filters, = normalize_callback_params(filter_list, block) [:raise] = true unless .key?(:raise) __update_callbacks(name) do |target, chain| filters.each do |filter| callback = chain.find { |c| c.matches?(type, filter) } if !callback && [:raise] raise ArgumentError, "#{type.to_s.capitalize} #{name} callback #{filter.inspect} has not been defined" end if callback && ( .key?(:if) || .key?(:unless)) new_callback = callback. (chain, if_option: [:if], unless_option: [:unless]) chain.insert(chain.index(callback), new_callback) end chain.delete(callback) end target.set_callbacks name, chain end end


BaseModel
Undocumented
-
Undocumented
-
Undocumented
-
In your implementation create a general ErrorController. If needed an error controller that is type specific can be made.
Declaration
Swift
var errorController: ErrorController {get set}
-
Undocumented
-
Set all properties from the received JSON at initialization
Declaration
Swift
init(json: AnyObject)
-
Set all properties from the received JSON
Declaration
Swift
func importFromJSON(json: AnyObject)
-
An url is formed from
. Declaration
Swift
static func contextPath() -> String
-
Override if you want to POST this as JSON
Declaration
Swift
func body()-> NSDictionary?


Free Next Day Delivery, Free Returns
We know how frustrating waiting is. Luckily your So & Mo delivery is 1 less thing you have to wait for! Start transforming your garden straight away with our free next day delivery (Orders before 12pm).
We plant 10 trees for every order and all our packaging is widely recycled so you know your product is produced responsibly.
Problem with your order? Contact us on live chat (At the bottom right of your screen) or email us using the form on our Contact Us Page.
What happens if I don’t see results?
We’re so confident you’ll see results with our products that we offer a Free Returns Policy. If you’re not happy with your order please email us to get your Royal Mail Free Post return label.
Returns address
1 Hulme Hall Road,
Cheadle Hulme,
Cheadle,
SK8 6JT


Simple Webpage
This is the simplest webpage ever!
Hi, my name is Dan
Things I like:
Computers
Programming
Beer
What Else Do I Like?


torchelastic on AWS¶
This directory contains scripts and libraries that help users run torchelastic jobs on AWS.
Prerequisites¶
Familiarity with basic AWS (EC2, Auto Scaling Groups, S3, EFS).
(suggested) install and setup
`awscli
<https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html>`__.Basic knowledge of containers (we use Docker in our examples).
Requirements¶
git clone https://github.com/pytorch/elastic.git
cd elastic/aws && pip install -r requirements.txt
The following AWS resources:
EC2 instance profile
EFS volume
S3 Bucket
Install the AWS Session Manager plugin
Quickstart¶
This guide shows how to get a simple torchelastic job running on AWS.
petctl
is a commandline tool that helps run distributed jobs written
with torchelastic on EC2 instances.
python3 petctl.py setup
This will bootstrap all the AWS resources required to run a torchelastic job. For details take a look at the CloudFormation template .
Use --s3_bucket
and --efs_id
to use an existing S3 bucket and
EFS file system. Otherwise an S3 bucket and EFS volume will be created.
IMPORTANT when specifying
--efs_id
you MUST ensure that NO mount targets exist on the EFS file system. torchelastic’s cfn stack will attempt to create mount targets for the subnets it creates and WILL FAIL if the file system already has mount targets on a different VPC. For more information refer to the EFS docs.
TIP: If the stack creation fails, log into the CloudFormation
console, inspect the failure reason, address the failure, then manually
delete the stack and re-run petctl configure
.
If you are familiar with AWS or already have the resources specified in
the Requirements section above, then you can follow the Manual
Setup instructions below and simply copy the sample specs
file and fill in the template, then run
python petctl.py configure
.
Write a script¶
If you already have a script that uses torchelastic to run distributed training, great! Otherwise you can use the provided imagenet example or classy vision. Or… this is a great time to work on one.
If you are using
examples/imagenet/main.py
you must download the imagenet dataset from here onto the EFS volume you specified. The dataset will be available to the workers on/mnt/efs/fs1/<download_dir>
.
Run the script¶
We will assume that you are working with the imagenet example and that
you have downloaded the imagenet dataset to
/mnt/efs/fs1/data/imagenet/train
. To run the script we’ll use
petctl
,
python3 aws/petctl.py run_job --size 2 --min_size 1 --max_size 3 --name ${USER}-job examples/imagenet/main.py -- --input_path /mnt/efs/fs1/data/imagenet/train
In the example above, the named arguments, such as, --size
,
--min_size
, and --max_size
are parameters to the run_job
sub-command of petctl
. In the example above, we created an
elastic job where the initial worker --size=2
, we are allowed to
scale down to --min_size=1
and up to --max_size=3
. This is used
by torchelastic’s rendezvous algorithm to determine how many nodes to
admit on each re-rendezvous before considering the group final and
start the train_step
.
The other positional arguments have the form:
[local script] -- [script args ...]
-- or --
[local directory] -- [script] [script args...]
If the first positional argument is a path to a script file, then the
script is uploaded to S3 and the script arguments specified after the
--
delimiter are passed through to the script.
If the first positional argument is a directory, then a tarball of the
directory is created and uploaded to S3 and is extracted on the
worker-side. In this case the first argument after the --
delimiter
is the path to the script relative to the specified directory and
the rest of the arguments after the delimiter is passed to the script.
In our example we specified
petctl.py run_job [...] examples/imagenet/main.py -- --input_path /mnt/efs/fs1/data/imagenet/train
We could have decided to specify the directory instead
petctl.py run_job [...] examples -- imagenet/main.py --input_path /mnt/efs/fs1/data/imagenet/train
TIP 1: Besides a local script or directory you can run with scripts
or tar
files that have already been uploaded to S3 or directly point
it to a file or directory on the container.
python3 petctl.py run_job [...] s3://my-bucket/my_script.py
python3 petctl.py run_job [...] s3://my-bucket/my_dir.tar.gz -- my_script.py
# or
python3 petctl.py run_job [...] docker:///abs/path/in/container/dir -- my_script.py
python3 petctl.py run_job [...] docker://rel/path/in/container/dir/my_script.py
TIP 2: To iterate quickly, simply make changes to your local script and upload the script to S3 using
python3 petctl.py upload examples/imagenet/main.py s3://<bucket>/<prefix>/<job_name>
TIP 3: Use the EFS volume attached on /mnt/efs/fs1
on all the
workers to save input data, checkpoints and job output.
Once the run_job
command returns log into the EC2 console, you will
see two Auto Scaling Groups 1. etcd server 2. workers
Inspect the logs¶
Log into the AWS CloudWatch Logs console. You should see a log group
called torchelastic/$USER
. Under it there will be a log stream per
instance with the name $job_name/$instance_id
(e.g.
my_job/i0b938EXAMPLE
).
Troubleshooting¶
SSH¶
To SSH onto the worker nodes to debug/inspect the worker process use AWS Session Manager instead of the ec2 key pair. Install the Session Manager plugin and run
# get the instance ids of the workers
python3 petctl.py list_hosts <job_name>
# ssh onto one of the workers
awscli ssm start-session --target <instance_id>
-- example --
awscli ssm start-session --target i-00b00EXAMPLE
Process Status and Logs¶
Once SSH’ed, the workers run in a docker container managed by
systemd
. You can take a look at their console outputs by running
# see the status of the worker
sudo systemctl status torchelastic_worker
# get the container id
sudo docker ps
# tail the container logs
sudo docker logs -f <container id>
Note since we have configured the log driver to be
awslogs
tailing the docker logs will not work. For more information see: https://docs.docker.com/config/containers/logging/awslogs/
You can also manually stop and start the workers by running
sudo systemctl stop torchelastic_worker
sudo systemctl start torchelastic_worker
EXERCISE: Try stopping or adding worker(s) to see elasticity in action! To add workers, simply increase the
desired
size of the worker autoscaling group.
Notable Directories¶
torchelastic_worker systemd:
/etc/systemd/service/torchelastic_worker.service
torchelastic run scripts:
/var/torchelastic
Note: by design,
petctl
tries to use the least number of AWS services. This was done intentionally to allow non-AWS users to easily transfer the functionality to their environment. Hence it currently does not have the functionality to query status of the job or to terminate the ASG when the job is done (there is nothing that is monitoring the job!). In practice consider using EKS, Batch, or SageMaker.
Stop the script¶
To stop the job and tear down the resources, use the kill_job
command:
python3 petctl.py kill_job ${USER}-job
You’ll notice that the two ASGs created with the run_job
command are
deleted.
Manual Setup¶
Create specs file¶
First, lets create a launch spec. This is a simple json file that
specifies the launch configuration of EC2 instances. We have included a
sample specs file so make a copy and fill
it in. You only need to fill in the fields with
{{ AWS_Resource_Id }}
, you can leave the other fields alone for now.
# cd $torchelastic_repository_root
mkdir ~/torchelastic_workspace
cp aws/config/sample_specs.json ~/torchelastic_workspace/specs.json
The specs file is divided into two sections: rdzv
and worker
. As
their names imply the rdzv
section contains the launch specs for the
instances of the rendezvous backend (e.g. etcd). The worker
section
contains the launch specs for the worker instances.
The following subsections describe the fields in the specs file.
Instance Type and Accelerator¶
"instance_type" : "[ec2 instance type]",
"accelerator" : "[none | gpu]",
The instance type specifies the EC2 instance type to use. The
accelerator
field can either be none
or gpu
. If an EC2
instance that has GPU capability is specified (e.g. g3
, p2
,
p3
instance families) then you must specify accelerator = gpu
.
If
accelerator=gpu
is not specified on a GPU capable instance type,petctl
assumes you will only use CPU and will use an AMI that does not have CUDA nor NVIDIA drivers.
Subnet¶
Note that you can add multiple subnets. Each subnet belongs to an availability zone (AZ) so you can spread your instances across AZs by specifying multiple subnets:
"subnets" : [
"[subnet_in_us-west-2a]",
"[subnet_in_us-west-2b]",
...
],
Some instances are not available in all AZs, make sure to create the subnet in the AZ that supports the instance type that you plan to run your jobs on.
Security Group¶
torchelastic jobs are distributed and hence require nodes to communicate with each other. Make sure that your security group allows all inbound traffic between instances within the same security group. > Optionally you may want to allow inbound SSH access in case you need to log into the instance for debugging.
EC2 Instance Profile¶
"instance_role" : "[ec2 instance profile]",
This is the IAM role that is used when accessing other AWS services from within the EC2 instance (e.g. accessing S3 from the worker host). To learn more about instance profiles refer to the AWS documentation.
Refer to the Ref: IAMRoleRendezvous
and Ref: IAMRoleWorker
resources in the CloudFormation template for a full
list of IAM policies that must be attached to this role.
You may wish to add other privileges to this role depending on what your workers do. For instance, if your job writes output to S3, then you will have to attach S3 Write IAM policy to this profile.
S3 Bucket and Prefix¶
petctl
uploads your local script to S3 and pulls it down on the
worker. Specify the S3 bucket and prefix for this purpose:
"s3_bucket" : "<YOUR S3 BUCKET NAME>",
"s3_prefix" : "<YOUR S3 PREFIX>"
Additional Worker Specs¶
Workers have a couple of additional specs compared to rdzv.
Docker Image¶
"docker_image" : "torchelastic/examples:0.1.0rc1",
Note that the worker
section in the specs file has an extra
docker_image
configuration. This is because the workers run in a
docker container whereas the rendezvous backend (etcd) runs directly on
the instance. The torchelastic/aws
image contains torchelastic
(along with all of its dependencies) and a few runtime utilities such as
the fetch_and_run
script that allows us to run arbitrary user
scripts. For production, you may consider creating your own docker image
with a custom ENTRYPOINT
specific to your application.
EFS¶
An Elastic File System volume is mounted on each worker instance (it is mounted through all the way to the container). EFS acts much like NFS in terms of semantics. Use it as if you were using NFS. You may store your input dataset, store model checkpoints, or job outputs here.
The specified EFS volume is mounted on
/mnt/efs/fs1
. On the host and container.
Configure petctl
¶
After creating a specs file, configure petctl
python3 petctl.py configure
This will prompt for the absolute path of your specs file and the
AWS region. You can run the configure
sub-command as many times as
you wish in case you made a mistake or you need to reconfigure
petctl
.
You’ll notice that after configuration is done, there is a config file
generated under $HOME/.petctl
.
This is similar to how the aws cli is configured. If you decide to skip configuration, then you must pass
--specs_file
and--region
arguments topetctl
each time (e.g.petctl --sepcs_file /home/$USER/specs.json --region us-west-2
).


TRANSLATE
enables you to make several single-character, one-to-one substitutions in one operation. This expression returns an expression with all occurrences of each character in one string replaced by its corresponding character in a second string.
CHAR | NCHAR | VARCHAR2 | NVARCHAR2
TRANSLATE(expr, from_string, to_string)
expr
is a text expression to be modified.
from_string
consists of one or more characters to be replaced in expr
.
to_string
consists of one or more characters that replace the corresponding characters in from_string
. This string can be shorter than from_string
, so that a null replaces the extra characters. However, to_string
cannot be empty.
TRANSLATE('disk', 'dk', 'Dc')
returns the value Disc
.


--- layout: post status: publish published: true title: QIM，拼音Switcher的福音 author: Leask author_login: leask author_email<EMAIL_ADDRESS>author_url: https://leaskh.com wordpress_id: 519 wordpress_url: http://leaskh.wordpress.com/2006/06/23/qim%ef%bc%8c%e6%8b%bc%e9%9f%b3switcher%e7%9a%84%e7%a6%8f%e9%9f%b3 date: '2006-06-23 18:52:19 +0800' date_gmt: '2006-06-23 18:52:19 +0800' categories: - Computers and Internet tags: [] comments: [] ---


The standard groups inspected by PeptideShaker are PSMs, peptides and proteins. However, if statistical
significance is ensured PSMs will be separated according to their charge. Similarly, peptides can be separated
based on their modification status.
This grouping strategy will allow you to increase the sensitivity of the processing without compromising robustness.
Note however that changes at the PSM level will affect results at the Peptide and Protein level. Similarly changes
at the Peptide level affects the Protein level.
It is thus important to apply the upstream changes first!
For more information about peptide grouping see
Vaudel et al: Peptide identification quality control,
Proteomics 2011;11(10):2105-14.
The estimator plots will help you improve the accuracy of confidence estimation by adjusting the bin size used to estimate the PEP.
When the PEP value is confidently estimated, probabilistic estimators provide a smoothed version of the classical estimators. However, sometimes the PEP cannot be
accurately estimated, e.g., for small populations. The confidence and probabilistic estimators will then no longer
be reliable.
It is advised to keep the PEP and FDR estimator advanced settings at the default values.
The score threshold used, illustrated by a red vertical line in the confidence plot, can be changed to meet three kinds of requirements:
Confidence: all hits with a confidence greater than the threshold will be validated.
By default the threshold is set to 1% FDR.
The identification summary provides essential metrics for the selected group:
This plot displays the confidence plotted against the score of the selected group's identifications. If the confidence is fluctuating,
the confidence estimation might not be robust enough and should be optimized as described above.
The red vertical line indicates the chosen threshold. The red area on the left of the threshold illustrates the amount of retained
true positives. The green area on the right of the threshold illustrates the amount of potential true positives not validated, i.e., the
false negatives.
Tip: It is important to verify that the confidence reaches 0, otherwise the total number of true positives will be under-estimated.
No red line is displayed? You should use a less restrictive threshold.
This plot displays the two FDR estimators and the FNR estimator plotted against the score of the selected group identifications.
If the two FDR estimators do not agree, the confidence estimation might not be robust enough and should be optimized.
Three points indicate the FDR and FNR of the validated identifications.
This plot displays the benefit which can be expected, the proportion of retained true positives (1-FNR), plotted against the cost of
the selected benefit, the proportion of false positive identifications (FDR). In other words it is a
ROC curve for the selected group.
A point indicates the performance at the selected threshold. It is possible to move this point along the curve (by moving the slider
below the plot) in order to optimize the threshold balancing between quality and quantity. If the point diverges away from the curve
the confidence estimation should be optimized.
This plot displays the Posterior Error Probability (PEP) plotted against the score of the selected group. If the PEP is fluctuating the confidence estimation is not robust enough and should be optimized.
This plot displays the probabilistic FDR plotted against the classical FDR for identifications with a confidence >0. The curve should closely follow the black diagonal. If this is not the case the confidence estimation should be optimized.


03 Jan 2019
Sri Lanka - Nuwara Eliya
Note: I found this draft in some subfolder to my website, based on the file timestamp I started writing this when I was in Singapore - so only 2 months after the events. With that in mind it seems only fair I finish and publish this now, a mere three and half years later. Strangely, much of it is still remarkably fresh in my mind…
“Great, so you can join us then.”
“But…I only just got here!”
“Yeah, but there’s nothing to do here.”
“Man, I haven’t slept in two days!”
“Hey, you get one full night and we head out tomorrow morning.”
The four of us sit on the balcony and drink beer. Two stories below us the garden is sinking into evening gloom while rain drops keep rolling off the tree tops around us. In the distance the regular racket picks up again: A swelling and ebbing sound somewhere between a flock of hyperactive ducks and a badly maintained machine gun. Horny frogs, apparently, flirting loudly. Every now and then a swooping shadow in the sky catches my eye as one of the huge fruit bats takes flight.
“Did you guys buy tickets yet?”
“We were thinking we’d just go down to the station and ask them for the easiest way to get to Nuraw-…Nawuru-“
“Nuwara Eliya.”
“That. So basically it would be a a few people from this hostel and us four.”
Us, that’s Hayden, Sam, Krzysztof and myself. While Sam has just arrived, the rest of us have already spent a day or two in Kandy, Sri Lanka. All of us arrived a week too late for the big Perahera festival and have already seen the things we wanted to see in town. In my case this list comprised the Temple of the Tooth (built around Gautama Buddha’s tooth - swanky temples are exactly what that man was all about), the botanical garden and the Commonwealth War Cemetery. Other than that I felt that Kandy was just a tad too noisy, crowded and busy for my taste. When somebody suggested to go south towards the big national parks I eagerly jumped on that plan. In the course of this evening a combination of bizarre and hilarious conversation (and more than a few beers) also convinces Sam to join us.
The next morning we eat an early breakfast, pack up our belongings and head out to rustle up a few tuktuks to take us down to the station. Since the other three are also travelling for longer periods they carry as little luggage as I do. A few others from the hostel, on the other hand, are there on vacation and have about three bags per person. Given the average number of hands per person, that seems like a bad idea, but then it’s not my problem, is it?
Tuktuks don’t have a whole lot of stowage so the short ride to the station ends up a being a rather cramped experience. So yes, in a way it’s also my problem now.
“So there is a train at 1pm.”
“Hm, our accommodation is only reserved until 2pm or so, so we’d miss that…”
“What, we have accommodation planned?”
“Well, the lady from the hostel sorted out something…”
“What’s the place called?”
“No clue, she gave the info to this one girl…”
“The blond one?”
“I don’t know…is the blond girl also the tall girl?”
“…”
Based on such definitive schedules we decide to take a small but air-conditioned shuttle bus instead, which should get us there on time for that dubious reservation.
I could now describe to you the exciting tropical mountain landscapes that passed by our bus windows but the truth of the matter is that I slept through most of the ride on account of a) being pretty tired from the previous night and b) being slightly over-bused after traveling on buses for about half a year. Looking at the route on Google Streetview the journey looks indeed leafy, somewhat moist, yet dusty, all the while hilly.
I slowly drift back to consciousness as we reach the town of Hawa Eliya. The bus pulls into a vacant parking lot on what appears to be the main street and comes to a shuddering halt. Sloth-like we grab our belongings and get off the bus groaning and yawning. I wasn’t the only one to sleep, it seems. We stand around in parking lot as the bus starts moving again and look after it slightly dazed. After a moment’s silence the group does that thing where one person accidentally takes a step in any direction and the rest of the group just goes “That way? Okay, right behind you!”
Hawa Eliya is located next to a very scenic lake and the entire town is quite presentable - many newer buildings, generally clean and well-kept. Not the part we’re in right now, but the rest is, we find out later. After a few hundred meters the first stomachs begin to growl irritably. This begins a pattern I would see play out a million times with other longer-term travellers: Everbody has to eat, but people who travel for a year or longer tend to stretch their budets a little. So a common meal is curry-with-rice, served in a shed.
 Everybody piles through the tiny entrance into the the spicy-smelling gloom beyond. Your eyes begin to water immediately and the steam hides a great many things better left unseen anyway. One of your group will eventually regain control of his vocal cords and yell into the boiling fog the immortal words “CURRYANDRICE - HOWMUCH?”
This will be answered by incomprehensible yelling from the kitchen, after which most of your group will look at each other nodding. You nod because you’re hungry, and because curry and rice is definitely on the menu, it’s often tasty and at whatever price that man is asking, there really is no point to even wondering what might be in that curry. But no, it’s not meant to be: There is always that one guy who angrily yells “60 RUPEES? THAT’S AN OUTRAGE, WE’RE LEAVING!” (60 Sri Lankan Rupees came to around 0.35 USD when I was there.)
And out of hungry, grudging solidarity with the most frugual of travellers, the group then files out through the exit and back into the sunlight. The group marches on, uniformly agreeing with one another that they were fully justified in not playing along with such a blatant rip-off. Eventually, another shed is found, the ritual repeated. Sooner or later you will eat.
So the natural question to ask is: Does that make sense? Why haggle over what comes to a price difference of 5 cents? Well…yes and no. If you don’t have a time limit on your travels, their duration is largely set by budget. So the difference between paying 60 rupees and paying 40 theoretically adds up to 50% longer trips. I say theoretically because obviously it doesn’t work that way: In many parts of the world food is only a small part of travel expenses - certainly if you’re willing to stick to curry and rice. Other expenses drive total cost, such as accommodation, transport, activities and drinking. And you know what goes really well with curry and rice, especially if finding it has taken you two hours? A nice, cold beer! It’s only 200 Rupees after all!
Until next time,
Arne


Huynh, T. D., Tsakalakis, N., Helal, A., Stalla-Bourdillon, S., & Moreau, L. (2022). Explainability-by-Design: A Methodology to Support Explanations in Decision-Making Systems. ArXiv Preprint ArXiv:2206.06251.
@article{huynh2022explainability,
title = {Explainability-by-Design: A Methodology to Support Explanations in Decision-Making Systems},
author = {Huynh, Trung Dong and Tsakalakis, Niko and Helal, Ayah and Stalla-Bourdillon, Sophie and Moreau, Luc},
journal = {arXiv preprint arXiv:2206.06251},
year = {2022}
}
Helal, A., & Otero, F. E. B. (2022). Data stream classification with ant colony optimisation. International Journal of Intelligent Systems, 37(9), 5725–5751.
@article{helal2022data,
title = {Data stream classification with ant colony optimisation},
author = {Helal, Ayah and Otero, Fernando EB},
journal = {International Journal of Intelligent Systems},
volume = {37},
number = {9},
pages = {5725--5751},
year = {2022}
}
Huynh, T. D., Tsakalakis, N., Helal, A., Stalla-Bourdillon, S., & Moreau, L. (2021). Addressing Regulatory Requirements on Explanations for Automated Decisions with Provenance—A Case Study. Digital Government: Research and Practice, 2(2), 1–14.
@article{huynh2021addressing,
title = {Addressing Regulatory Requirements on Explanations for Automated Decisions with Provenance—A Case Study},
author = {Huynh, Trung Dong and Tsakalakis, Niko and Helal, Ayah and Stalla-Bourdillon, Sophie and Moreau, Luc},
journal = {Digital Government: Research and Practice},
volume = {2},
number = {2},
pages = {1--14},
year = {2021},
publisher = {ACM New York, NY, USA}
}
Tsakalakis, N., Stalla-Bourdillon, S., Carmichael, L., Huynh, T. D., Moreau, L., & Helal, A. (2021). The dual function of explanations: Why it is useful to compute explanations. Computer Law & Security Review, 41, 105527.
@article{tsakalakis2021dual,
title = {The dual function of explanations: Why it is useful to compute explanations},
author = {Tsakalakis, Niko and Stalla-Bourdillon, Sophie and Carmichael, Laura and Huynh, Trung Dong and Moreau, Luc and Helal, Ayah},
journal = {Computer Law \& Security Review},
volume = {41},
pages = {105527},
year = {2021},
publisher = {Elsevier Advanced Technology}
}
Marzagão, D. K., Huynh, T. D., Helal, A., Baccas, S., & Moreau, L. (2020). Provenance graph kernel. ArXiv Preprint ArXiv:2010.10343.
@article{marzagao2020provenance,
title = {Provenance graph kernel},
author = {Marzag{\~a}o, David Kohan and Huynh, Trung Dong and Helal, Ayah and Baccas, Sean and Moreau, Luc},
journal = {arXiv preprint arXiv:2010.10343},
year = {2020}
}
Huynh, T. D., Tsakalakis, N., Helal, A., Stalla-Bourdillon, S., & Moreau, L. (2020). King’s Research Portal.
@article{huynh2020king,
title = {King’s Research Portal},
author = {Huynh, TD and Tsakalakis, N and Helal, A and Stalla-Bourdillon, S and Moreau, L},
year = {2020}
}
Salama, K. M., Abdelbar, A. M., Helal, A. M., & Freitas, A. A. (2017). Instance-based classification with ant colony optimization. Intelligent Data Analysis, 21(4), 913–944.
@article{salama2017instance,
title = {Instance-based classification with ant colony optimization},
author = {Salama, Khalid M and Abdelbar, Ashraf M and Helal, Ayah M and Freitas, Alex A},
journal = {Intelligent Data Analysis},
volume = {21},
number = {4},
pages = {913--944},
year = {2017},
publisher = {IOS Press}
}
Helal, A. M., & Abdelbar, A. M. (2014). Incorporating domain-specific heuristics in a particle swarm optimization approach to the quadratic assignment problem. Memetic Computing, 6, 241–254.
@article{helal2014incorporating,
title = {Incorporating domain-specific heuristics in a particle swarm optimization approach to the quadratic assignment problem},
author = {Helal, Ayah M and Abdelbar, Ashraf M},
journal = {Memetic Computing},
volume = {6},
pages = {241--254},
year = {2014},
publisher = {Springer Berlin Heidelberg}
}
Refereed conference proceedings
Tsakalakis, N., Carmichael, L., Stalla-Bourdillon, S., Moreau, L., Huynh, D., & Helal, A. (2020). Explanations for AI: Computable or Not? Companion Publication of the 12th ACM Conference on Web Science, 77–77.
@inproceedings{tsakalakis2020explanations,
title = {Explanations for AI: Computable or Not?},
author = {Tsakalakis, Niko and Carmichael, Laura and Stalla-Bourdillon, Sophie and Moreau, Luc and Huynh, Dong and Helal, Ayah},
booktitle = {Companion Publication of the 12th ACM Conference on Web Science},
pages = {77--77},
year = {2020}
}
Helal, A., Brookhouse, J., & Otero, F. E. B. (2018). Archive-based pheromone model for discovering regression rules with ant colony optimization. 2018 IEEE Congress on Evolutionary Computation (CEC), 1–7.
@inproceedings{helal2018archive,
title = {Archive-based pheromone model for discovering regression rules with ant colony optimization},
author = {Helal, Ayah and Brookhouse, James and Otero, Fernando EB},
booktitle = {2018 IEEE Congress on Evolutionary Computation (CEC)},
pages = {1--7},
year = {2018},
organization = {IEEE}
}
Helal, A., & Otero, F. E. B. (2017). Automatic design of ant-miner mixed attributes for classification rule discovery. Proceedings of the Genetic and Evolutionary Computation Conference, 433–440.
@inproceedings{helal2017automatic,
title = {Automatic design of ant-miner mixed attributes for classification rule discovery},
author = {Helal, Ayah and Otero, Fernando EB},
booktitle = {Proceedings of the Genetic and Evolutionary Computation Conference},
pages = {433--440},
year = {2017}
}
Helal, A. M., Jawdat, E., Elnabarawy, I., Wunsch, D. C., & Abdelbar, A. M. (2017). Integrated particle swarm and evolutionary algorithm approaches to the quadratic assignment problem. 2017 IEEE Symposium Series on Computational Intelligence (SSCI), 1–5.
@inproceedings{helal2017integrated,
title = {Integrated particle swarm and evolutionary algorithm approaches to the quadratic assignment problem},
author = {Helal, Ayah M and Jawdat, Enas and Elnabarawy, Islam and Wunsch, Donald C and Abdelbar, Ashraf M},
booktitle = {2017 IEEE Symposium Series on Computational Intelligence (SSCI)},
pages = {1--5},
year = {2017},
organization = {IEEE}
}
Helal, A., & Otero, F. E. B. (2016). A mixed-attribute approach in ant-miner classification rule discovery algorithm. Proceedings of the Genetic and Evolutionary Computation Conference 2016, 13–20.
@inproceedings{helal2016mixed,
title = {A mixed-attribute approach in ant-miner classification rule discovery algorithm},
author = {Helal, Ayah and Otero, Fernando EB},
booktitle = {Proceedings of the Genetic and Evolutionary Computation Conference 2016},
pages = {13--20},
year = {2016}
}
Helal, A., & Balasa, F. (2015). Multithreaded Signal-to-Memory Mapping Algorithm for Embedded Multidimensional Signal Processing. 2015 20th International Conference on Control Systems and Computer Science, 255–260.
@inproceedings{helal2015multithreaded,
title = {Multithreaded Signal-to-Memory Mapping Algorithm for Embedded Multidimensional Signal Processing},
author = {Helal, Ayah and Balasa, Florin},
booktitle = {2015 20th International Conference on Control Systems and Computer Science},
pages = {255--260},
year = {2015},
organization = {IEEE}
}
Helal, A., Jawdat, E., & Abdelbar, A. M. (2015). An improved Particle Swarm Optimization/Tabu search approach to the Quadratic Assignment Problem. 2015 IEEE Congress on Evolutionary Computation (CEC), 220–226.
@inproceedings{helal2015improved,
title = {An improved Particle Swarm Optimization/Tabu search approach to the Quadratic Assignment Problem},
author = {Helal, Ayah and Jawdat, Enas and Abdelbar, Ashraf M},
booktitle = {2015 IEEE Congress on Evolutionary Computation (CEC)},
pages = {220--226},
year = {2015},
organization = {IEEE}
}


WorldWide Telescope Planetarium
Input
Base of triangle A:
Inches (unchecked is metric):
Base height of support:
Dome tilt angle:
Specifications
Side lengths of triangle A:
Side lengths of triangle B:
Panel
Width
Left Height
Right Height
1 x short rectangular panel:
2 x side panels:
2 x side panels:
2 x side panels:
2 x side panels:
1 x tall rectangular panel:
Dome support angles
A
B
C
Angle in degrees:
Dome width:
Dome length:


emoncms emoncms
.emonGLCD
Hallo
I have successfully mounted the kit openenergymonitor.
I have two problems!
1)the clock on emonGLCD goes back 2 hours. I tried to set UTC by emoncms (raspberry) but nothing has changed
2) In emoncsl can not correctly display the temperature that I take from the display. Temperature on emonGLCD 20,10 on emoncms 201, practically multiply by 100.
Thank
and sorry for my english
Re: emonGLCD Time and emoncms Temperature
Hi
Can't help with time.
But for temperature insert a X 0.01 on a line above your log to feed line.
Regards
Ian
Re: emonGLCD Time and emoncms Temperature
Thank Ian
the temperature is right now.
missing only fix the time on the display!!!
Re: emonGLCD Time and emoncms Temperature
hi - I found I can get the emonGLCD time correct by updating the timezone line in /etc/php5/cli/php.ini. The allowed values are on the php web site. There are a few other forum entries here that seem to say this is ok. Mine is set to Australia/Sydney.
BUT - for me, at least, when I do this, the "updated" column on the feeds view then shows incorrect values. Instead of values like "5 seconds ago" I get values like "60 minutes ago".
I have tried to figure this out, by adding some extra output fields in the "echo" line in raspberrypi_run.php, and restarting with the "log" argument, but so far this only shows that the timezone is correctly going through to raspberrypi_run.php. I think somehow the javascript running on the browser thinks its reference time is 1 hour different. As a very bad fix I put in some lines to put change the timezone to "Antarctica/Macquarie" just before the send to the LCD, and then revert to correct localtime after that. The Antarctica/Macquarie timezone is one hour different from current localtime, and this timezone is mentioned in lots of google hits as meaning you need to set a correct timezone in php.ini as describe above. But I've done that....
Anyway maybe it will work for you!
Re: emonGLCD Time and emoncms Temperature
I changed php.ini, but without success.
for raspberrypi_run.php, when I run it, I always get "Already running"
Thank
Re: emonGLCD Time and emoncms Temperature
You just need to stop it first. You can do something like:
Its also worth knowing that you can get some logging information with:
but if you do that, afterwards be sure to stop it again, and restart it without the "log" keyword. The log file will be at /var/log/rfm12piphp.log.
Re: emonGLCD Time and emoncms Temperature
I attach a log!!!!!!!
Re: emonGLCD Time and emoncms Temperature
Sending remote data remotedata:[[1,10,339,0,0,21971],[1,20,2625],[2,10,336,0,0,22009],[2,20,2625],[2,10,339,0,0,21993],[2,10,335,0,0,21988],[2,20,2625],[2,10,338,0,0,22002],[2,10,333,0,0,22005],[2,20,2631],[3,10,338,0,0,22002],[3,10,338,0,0,21998],[3,20,2625],[3,10,335,0,0,22008],[3,20,2631],[3,10,333,0,0,22027],[4,10,335,0,0,22013],[4,20,2625],[4,10,337,0,0,22019],[4,10,338,0,0,21996],[4,20,2625],[4,10,339,0,0,22006],[4,10,334,0,0,22019],[4,20,2631],[5,10,330,0,0,22007],[5,20,2625],[5,10,328,0,0,21980],[5,10,336,0,0,21995],[7,20,2631],[19,10,336,0,0,21978],[21,10,335,0,0,22026],[21,20,2625],[21,10,337,0,0,22001],[27,10,343,0,0,21989],[27,20,2625]]
Re: emonGLCD Time and emoncms Temperature
MESSAGE RX1:12 Jun 13 - 22:05
MESSAGE RX1:> 0s
LENGTH: -> 4 b
DATA RX: 10 82 1 0 0 0 0 4 86
00,22,05,00s
DATA RX: 20 71 10
DATA RX: 10 84 1 0 0 0 0 232 85
Re: emonGLCD Time and emoncms Temperature
Out of the box the time on my emonGLCD is 1 hour out (showing UTC instead of BST). Log in remotely to the Pi via Putty or if you have Keyboard/screen attached use that and run sudo raspi-config then go to option 4 Internationalisation Options then I2 Change Timezone - select your local timezone then save and you should soon see your time update on the emonGLCD. Not sure if a reboot of the Pi is necessary.
Regards, Keith
Re: emonGLCD Time and emoncms Temperature
Thank deskyeti
Timezone is the solution!!!!!!!!!!!!


Some more basic Javascript
This week we have a look at some of the cornerstones of writing code: the use of parentheses, braces, brackets, and single and double quotes. They are used to tell the program to interpret things a certain way, much like punctuation does in written language. Below are all of the case uses that I can think of these on Javascript.
Parentheses ( )
These are used in a way that is similar to maths in the sense that you can use them to tell the computer to do some action first before proceeding to the next. The difference is that it not only applies to mathematical operations, but also logical and others. It is telling the program "do this first, then proceed with the rest".
(6 + 6) + "is the result of the operation"
Following this they are used in loops to express a condition that needs to happen for the loop to continue or in a simple "if" to proceed with the content of the expression.
if (winner === true){
lib.displayMessage('You win!');
}
Parentheses also define the arguments that will be passed to a function. This is done when we "call" the function as well. They way to write this is to put the name of the function first and then the parenthesis with whatever the information we want it to use. When we have a function that does not use any arguments we still add them but this time empty.
generateBoard();
function countSurroundingMines (cell) { }
Brackets [ ]
These are used to define arrays and to contain the things in them.
var cells = ["cell1", "cell2"]
They are also used to index parts of the array in order to find them from outside of it. All elements on an array have an order number starting from 0 so if we want to get the second object on our array we call it like this:
cells[1]
In a similar way to arrays, brackets are also used to find a property for an object, only in this case the property name needs to be in quotes or double quotes (string).
board = {cells: "black"}
board["cells"]
Braces { }
Braces are used to define Objects in Javascript as in the previous example
board = {cells: "black"}
They also wrap functions and loops when expressing the action to be done.
Single quotes ' ' and double quotes " "
They are used to define the limits of a string. You can use one of the other but not a combination of both.


Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
“Simple is good.” - Jim Henson


pythainlp.tokenize¶
The pythainlp.tokenize
contains multiple functions for tokenizing a chunk of Thai text into desirable units.
Modules¶
-
pythainlp.tokenize.
word_tokenize
(text, engine='newmm', whitespaces=True)[source]¶ Parameters: Parameters for engine: - newmm (default) - dictionary-based, Maximum Matching + Thai Character Cluster
- longest - dictionary-based, Longest Matching
- icu - wrapper for ICU, dictionary-based
- deepcut - wrapper for deepcut, language-model-based https://github.com/rkcosmos/deepcut
- ulmfit - use newmm engine with a specific dictionary for use with thai2vec
Returns: list of words, tokenized from the text
- Example::
>>> from pythainlp.tokenize import word_tokenize >>> text = "โอเคบ่พวกเรารักภาษาบ้านเกิด" >>> word_tokenize(text, engine="newmm") ['โอเค', 'บ่', 'พวกเรา', 'รัก', 'ภาษา', 'บ้านเกิด'] >>> word_tokenize(text, engine="icu") ['โอ', 'เค', 'บ่', 'พวก', 'เรา', 'รัก', 'ภาษา', 'บ้าน', 'เกิด']
-
pythainlp.tokenize.
dict_word_tokenize
(text, custom_dict, engine='newmm')[source]¶ dict_word_tokenize()
tokenizes word based on the dictionary you provide. The format has to be in trie data structure. :param str text: text to be tokenized :param dict custom_dict: a dictionary trie :param str engine: choose between different options of engine to token (newmm, longest) :return: list of words Example:>>> from pythainlp.tokenize import dict_word_tokenize, dict_trie >>> words = ["แมว", "ดี"] >>> trie = dict_trie(words) >>> dict_word_tokenize("แมวดีดีแมว", trie) ['แมว', 'ดี', 'ดี', 'แมว']
-
pythainlp.tokenize.
subword_tokenize
(text, engine='tcc')[source]¶ Parameters: Returns: a list of tokenized strings.
-
pythainlp.tokenize.
sent_tokenize
(text, engine='whitespace+newline')[source]¶ This function does not yet automatically recognize when a sentence actually ends. Rather it helps split text where white space and a new line is found.
Parameters: Returns: a list of text, split by whitespace or new line.
-
pythainlp.tokenize.
dict_trie
(dict_source)[source]¶ Create a dict trie which will be used for word_tokenize() function. For more information on the trie data structure, see: https://marisa-trie.readthedocs.io/en/latest/index.html
Parameters: dict_source (string/list) – a list of vocaburaries or a path to source file Returns: a trie created from a dictionary input


Approaches to Problem Solving
9 May 2020
That time I got blocked on a simple problem
A couple of weeks ago we needed to create our blog website using HTML and CSS. I wanted the content sections of my index page to stack up in rows, as per the screenshot of my current index page below. By default, HTML stacks up web content elements vertically.  I just couldn't figure out how I had done this.
After a few hours looking through my code and trying different ways to fix the issues and getting more frustrated by the minute, I decided to ask a friend in Canada to help me out. He had a look at my code and initially couldn't work out the problem either. By this time I decided I needed to sleep so I left him with the code.
Morning came and I checked for messages from my friend. Surely enough he found the bug. If you remember from my previous blog, CSS changes the behaviour and look of HTML elements. Long story short, I had coded a few CSS properties that put all the sections into one box and then make them line up next to each other. All I had to do was remove those properties to fix the problem.
Moral of the story is, sometimes a problem isn't as complicated as you think. Also it's probably best not to keep coding into the obscene hours of the morning when you've already been coding all evening. Try sleeping on coding problems instead.
A time I solved a problem in an elegant way
I wouldn't call my attempts at solving coding problems so far elegant. However, I can talk about when I was able to work through a challenge we were given to solve without wanting to tear my hair out. It was for the JS Gradebook kata in this week's sprint.
I found that with this kata I was mostly able to slow down my thought process and break things down step-by-step. This was because I took the time to make sure I understood the instructions given to us for the challenge. I also went back to read them again when necessary.
I managed to complete the kata by myself using different problem solving approaches. I was able to find mostly the right resources through Google searches within a reasonable timeframe. I managed to understand the technical documentation on MDN Web Docs for the codes required. I used the trial and error method throughout the challenge. I also read through the blog linked on the kata information page which made me realise I needed to change something I had written in a previous code.
I learned that when I'm able to slow down my thought process I could tackle something new on my own better. Although I also credit this to having the instructions in the kata information as a guide. This means that I need to work on my skills in breaking down a big coding challenge into smaller chunks of challenges for when I don't have instructions to follow.Confidence levels on various problem solving approaches
Pseudocode :
When we had to do this for the Super FizzBuzz kata, I found it difficult to write coding steps in simple English that a human can understand i.e. pseudocode. This is mainly due to the fact that I didn't fully understand what I was actually meant to do in order to solve the challenge. I ended up writing pseudocode for another kata after I'd gotten a solution and found it easier to do that way. Pseudocode is a valuable skill I'd like to develop so I'll see how I go with doing it again next time.
Trial and error :
Trying things is definitely my preferred approach. In the past I'd taught myself to use different computer softwares through trial and error. In saying that, I've found in the last week that it can be counterproductive if not used wisely. At times when I'd gotten blocked I wish I'd spoken to someone else about it sooner to help clarify my thinking instead of festering. When the direction isn't so murky though, trial and error works wonders.
Rubber ducky method :
This involves talking to an inanimate object like a rubber duck about what you've done so far, what the problem is etc. until you eventually identify the source of the problem. I tried to do this with the rubber ducky app on my phone for the Super FizzBuzz kata but as I didn't have a decent understanding of what I was meant to do, it was a fruitless attempt. Perhaps in time as I gain more experience with coding it will be useful.
Reading error messages :
Error messages are hard to avoid in Repl.it where we solve the katas on. I usually read them or at least skim for the necessary details. Many times from reading the error messages I could then fix a problem from there, sometimes by combining what I gathered from the message with another approach like trial and error. At times though I can barely understand the messages so in these instances I don't find them useful.
Console.logging :
I used this a lot during the freeCodeCamp lessons once I figured it out and found it really helped being able to see what a function was doing. I used it heaps during the katas as well. There have been times though when I used the method incorrectly as I'm still learning. In general I do find it to be a great tool especially for trying things.
Google search :
I've found that using Google search can be a hit and miss; that there's an art to it that I've yet to discover. There have been times I found the right resources to help me solve problems within a reasonable timeframe. Other times though no matter how many attempts I made at changing my search terms I wasn't able to pull up the right resources. It's still a go to but I definitely need to refine my Google search skills so that it'll become a more helpful tool for me.
Asking peers for help :
Earlier on during EDA Foundations I reflected that I need to work on asking for help and I had a revelation about it this week. After being blocked for a while, I asked a friend who's a web developer if he could help me out with one function over video call. We walked through and worked out every step to pass the rest of the tests together. I was able to ask him a lot of questions, he checked my understanding, explained concepts using useful analogies and got me to try things to see what would happen. Once we passed the tests he got me to loop back what I understood each line of the final solution was doing and clarified things further.
This is what collaboration looks like. It took almost an hour and a half but as a newbie with zero experience with JavaScript prior to last week, this way of bouncing off questions and explanations and trial and error with someone more experienced in JavaScript was incredibly useful and energising.
Asking facilitators for help :
In the last couple of weeks, there were a few times I got so blocked for hours that it felt debilitating and I ended up asking my facilitator for help. I told myself earlier on during Foundations to only do so as a last resort. Recently though I've come to realise that as a complete beginner in JavaScript there's no shame in asking the facilitators for help as I'm still learning. Sometimes I don't know what I don't know and one of the reasons I chose EDA is the support available from the facilitators due to the small cohort numbers. In all honesty, the barrier to my asking the facilitators for help is actually feeling like I'm useless for having to do so.
Improving process with reflection :
I spend a lot of time on the reflections we are asked to write, mainly to benefit my own learning. At first it seemed like a lot of work but after a while I realised that while it can be time consuming and uncomfortable it's often helped me identify areas of improvement. Knowing about these means I can come up with new ways of approaching problems and I gain a different perspective. Hindsight is a powerful thing.