text:
Book Bus Tickets From Jalod
Bus Tickets to Jalod
Home > Bus Tickets > Jalod
All Bus Routes From Jalod
Sorry! No routes available from Jalod at this moment. Click here to go to Home.
About Jalod
Jalod
Jalod, a historical town in Gujarat's Dahod district, is famous for its commerce and trade. There were many freedom fighters from this town. This town was named Zalod, from the Zalai Mata Temple located within the town. There is also a small fort built by the Maratha warriors worth visiting. Some of the nearby cities include Dahod, Lunawada, Banswara and Jabua.
There are no budget hotels available in Jalod. For budget hotels, one has to travel to Godhra, which is 83 km away. The hotels found here are Hotel City Inn (Tariff-Rs.940) and Hotel Atithi and Guest House (Tariff-Rs.218).
The languages spoken in Jalod are Gujarati and Hindi.
The most celebrated festivals in Jalod are the Kite Festival in January, Holi in March, Janmashtami in August, Ganesha Chaturthi in August-September and Diwali in November.
There are a few places of interest around Jalod. These attractions are Machhan Reservoir (7 km), Kali Reservoir (37 km), Karath (15 km) and Santrampur (34 km) away from Jalod.
The nearest airport is situated in Vadodara, which is 156 km away from Jhalod.
There is no railway station in Jalod. The closest railway station is located in Dahod, which is 34 km away from this town.
Jalod is constantly bustling with state-run and private buses from neighbouring towns and states. Private bus operators such as Jain Travels run Volvo A/C buses from Jodhpur to Jhalod. Volvo bus booking through online bus ticket booking website like Ticketgoose.com is the most preferred choice of travellers.


text:
Q: What happens to tree stumps in Don't Starve? When cutting trees in Don't Starve I don't want to reach a point in the game where my world is terrible and flat, without any trees in it. I usually leave the stumps and use the pine cones to build a forest around my own camp (to protect it, and the pigmen in it)
What happens to the stumps left behind after cutting a tree? Does a tree eventually grow from those stumps, or should I dig out the tree and plant a new one instead? I know the latter is more efficient but it also leaves me with less pine cones.

A: Aside from digging a stump with 1 use of a shovel, which would get you just 1 log, you can set the stump on fire and get 1 ash instead. That can save you a lot of time, but be sure to control the fire by first digging out the stumps in a desired perimeter. Wind will blow away an ash pile after 20 seconds of it lying on the ground.
Or don't bother limiting the fire zone and just set the world on fire to get some additional burned trees, each of which get you 1 charcoal and an occasional pinecone for just 1 axe hit.

A: As far as I can tell, nothing happens to a stump over time.  As you pointed out, you can remove stumps by digging them up with a shovel.

A: Stumps do not regrow, your only option is to plant pine cones to replace them. If left they will simply remain as an obstacle on the map until you dig them up with a shovel or burn them.

redpajama_set_name: RedPajamaStackExchange


text:
Why the Thames Valley
Advanced Engineering and Manufacturing
Environment, Energy and Infrastructure
Europe, the Middle East and Africa
Talent and Innovation
Bucks New University
UTC Oxfordshire
UTC Reading
UTC Swindon
UTC Silverstone
page-template-default,page,page-id-12483,page-child,parent-pageid-12481,strata-core-1.0.1,strata-child-theme-ver-1.0.0,strata-theme-ver-3.0.3,ajax_fade,page_not_loaded,wpb-js-composer js-comp-ver-5.7,vc_responsive
The UK has a long history of making world-class video games, with over 2,000 companies across the full spectrum of games technologies – from console, mobile and PC, to fast-developing sectors such as VR/AR and Artificial Intelligence.
The UK Government provides support to companies in the sector. For example, the UK Games Fund has spent £5m helping 70 studios since 2014 and the Video Games Tax Relief has supported approximately 480 productions.
With the global market expected to grow to $118.6 billion by 2019, the opportunities for the UK Games industry have never been greater.
"I strongly believe that the nexus of art and technology is how Britain will pay her way in the 21st Century. Video games are right at the heart of this nexus. They were born digital and exhibit some of the best creativity Britain has to offer."
Matt Hancock, Former Minister for Culture and Digital
Located close to the Guildford cluster of gaming businesses, the Thames Valley is home to truly global computer game companies who have produced some of the most popular content.
A German global independent developer, marketer and publisher of interactive entertainment software, the company specialises in strategy and simulation games, including 'Sins of a Solar Empire' and the 'Tropico' series.
Nintendo Europe
Also situated in Windsor is one of the most well-known video game companies in the world, with Pokemon and Super Mario Brothers being their most famous products. Nintendo chose the town as a base for its UK workings, including product management, marketing and operations.
The Japanese giant has its European headquarters in Windsor, within walking distance of the Castle. It set up this office with help from the Department of International Trade and the Thames Valley Chamber of Commerce.
TT Games Publishing
Famous for their Lego Star Wars titles and holding the worldwide rights to develop Lego video games, the company was acquired by Warner Bros in 2007. The Group includes the games development studio TT Fusion and TV production company TT Animation.
NaturalMotion
Bought by San Francisco-based Zyenga for $527m in 2014, over half of its 300+ workforce is located in the Thames Valley. As well as its own impressive portfolio of games, NaturalMotion has provided software for games such as Grand Theft Auto IV and Bioshock Infinite.
The Next Gen Skills Academy
A national centre of excellence for the games, visual effects and animation industries, they work with leading employers to develop qualifications, training and courses. This ranges from taster sessions in schools right through to career development training for industry professionals.
One of Europe's largest independent game developers, it has had 24 number one hit games, including Alien vs Predator and Sniper Elite. The company now employs 200+ people, the majority of them at its studio base in the Thames Valley. Rebellion collaborates with the University of Oxford, who are right on their doorstep, in particular when hiring graduates and enabling training to include relevant programming skills.
Talent & Innovation
£4bn committed to University of Oxford in new partnership July 18, 2019
Chancellor shown transformative energy technology at Culham Centre for Fusion Energy June 10, 2019
Barcelona Biotech Breakfast: Opportunity for Thames Valley organisations to attend June 10, 2019
New Directory to drive foreign investment June 7, 2019
© Copyright Thames Valley UK

redpajama_set_name: RedPajamaCommonCrawl


Directions: Product is easily divided into 8 x 10mg doses. First time users take a single 10 mg dose. Allow 60-90 minutes for full effect before an addition dose considered. Take with food for best results.


One of the biggest challenges for classroom teachers is providing effective classroom management. One thing I have noticed from observing highly effective teachers is that nearly all of them use "tried and true" phrases to manage their classrooms throughout the course of the day. These expressions are easy to remember, effective, and FUN!
I have recently begun to collect and share some of my very favorite teacher expressions on Instagram, Facebook, Twitter and Tumblr. Today I am rounding up all of the quotes I shared throughout the month of January and I am excited to share the collection with you.
Why, why, WHY do young children love tattling on each other so much? Unfortunately, tattling just comes along with the territory of being a teacher; but the more you listen to tattles, the more persistently children do it. If you send a clear message that children need to worry about their own problems and not the misbehaviors of their friends, it will cut the tattles WAY down in the classroom. I do not indulge classroom tattles and as a result, I have very few "classroom informants" this year. This expression sends a very clear message that each student's personal responsibilities are enough for them to be concerned about.
2) That throwing away their garbage is not part of my job.
Nowadays, I hardly ever receive any bits of paper, old stickers or staples that children find on the floor. They deal with these items themselves.
The teacher's job in the classroom is pretty clear. Her job title says it all: she teaches. (Or he teaches, if the teacher is a male.) For students, their job in the classroom may not be so clear. Some children may not realize or may forget that they are in school for a purpose: to learn. Children love to play and talk and be silly with their friends. Often, a simple reminder that they do, in fact, have a job within the classroom (to learn) is all it takes to get him or her on track.
Now that we've established what your job is (teacher), what your job isn't (garbage collector) and what a student's job is (to learn). Let's talk about the difference between a name and a job. Sometimes the little ones need someone to very clearly explain this difference. This #KinderCatchPhrase hits the nail right on the head!
Students forgetting to write their names on assignments is a problem across ALL grade levels. From kindergarten to high school, educators are constantly reminding forgetful students to write their names (and teaching the consequences of what happens when you forget). This little chant serves as a great reminder for students when they begin. Often, children internalize reciting this chant as part of their routine and they say it out loud without the teacher to prompt them!
FACT: Young children often struggle with self control.
FACT: Young children are proud of the knowledge they possess.
FACT: Young children like to help their friends.
All of these facts can be quite problematic for a teacher during test time in the classroom. You know all-too-well the problems that can arise while testing young children. Students who know the answer often say it aloud instead of silently recording it on their paper. Or, when a child knows the answer and sees that a friend beside them does not, the first child leans over to "help" their friend do well on the test. Sigh. This classroom expression helps to resolve both of those issues.
I am a firm believer that teachers should NEVER have to raise their voices in the classroom. Teachers can only effectively raise their voice in the classroom one time. The first time it happens, is is shocking and gets attention because the class doesn't know how to react to a teacher that yells. Each subsequent time that the teacher raises his/her voice, it becomes slightly less effective; until it becomes so much of a norm that the students no longer react or care. Instead of yelling to get your class' attention, teach your children the chant: "Macaroni and cheese… everybody freeze!" It's clever, it rhymes, it involves a favorite food of nearly every child and the children know that they need to freeze and listen.
Once you have your students' attention, don't let go of it! Remind your class that they really need to listen to what you are about to say.
Your job is to teach, not to enable students. It's ok to stop doing everything for the children that you teach. After all, you are doing more than filling their heads with facts and procedures – you are teaching your students to become more independent. Stop tying shoes and zipping coats. If a child needs help, make them responsible for finding a solution. Encourage your students to ask three friends for help before seeking help from the teacher. This sends a message that you do care enough to help, but their friends are excellent helpers, too. Young children love having an opportunity to be a "classroom expert." Let the shoe-tying expert help with this task – it will actually motivate more students to become experts and it will allow you to keep your attention on more important things, like the safety of the children in your care.
Tying shoelaces isn't the only common problem that children can easily solve for themselves. It's ok to stop solving every trivial problem for your students. It's even ok to stop solving some medium-sized problems for them. When a child has a problem, instead of rushing in to impose your solution, take a step back and as the child "How are you going to solve that problem?" It's a wonderful way to foster independence and critical thinking. Plus, you just might be surprised by the thoughtful and creative solutions that result.
Let's talk about one small (but gigantically annoying) classroom occurrence: poking the teacher to get her attention. Don't get me started! I am a person that greatly values my personal space. I'm quick to give a hug in need, and I don't mind if a student touches my shoes while we gather for circle time but I really need the teacher-poking to stop. I love this expression because it reminds students that it's just not ok to stick your finger at someone to get their attention.
You can also check back at the end of February for the latest round up on the blog. Become a subscriber to have the latest blog posts delivered right to your inbox!
I love the woodpecker one, I'm going to use that!
Love this! I think at one time or another I have used all of these.
Thank you for helping us to be mindful of cultural differences. In some schools (such as my own) there are very few children that are Spanish-speaking. Some children are genuinely learning the proper way to address adults, but I completely agree that those experiences are situational.
hahahahahah… i love that one!


text:
package rockredis

import (
	"encoding/binary"
	"errors"
	"runtime"
	"sync"
	"time"

	"github.com/youzan/ZanRedisDB/common"
	"github.com/youzan/ZanRedisDB/engine"
)

var (
	errExpMetaKey = errors.New("invalid expire meta key")
	errExpTimeKey = errors.New("invalid expire time key")
)

const (
	logTimeFormatStr = "2006-01-02 15:04:05"
)

var errExpType = errors.New("invalid expire type")

/*
the coded format of expire time key:
bytes:  -0-|-1-2-3-4-5-6-7-8-|----9---|-10-11--------x-|
data :  103|       when      |dataType|       key      |
*/
func expEncodeTimeKey(dataType byte, key []byte, when int64) []byte {
	buf := make([]byte, len(key)+1+8+1)

	pos := 0
	buf[pos] = ExpTimeType
	pos++

	binary.BigEndian.PutUint64(buf[pos:], uint64(when))
	pos += 8

	buf[pos] = dataType
	pos++

	copy(buf[pos:], key)

	return buf
}

/*
the coded format of expire meta key:
bytes:  -0-|----1-----|-2-3----------x--|
data :  102| dataType |       key       |
*/
func expEncodeMetaKey(dataType byte, key []byte) []byte {
	buf := make([]byte, len(key)+2)

	pos := 0

	buf[pos] = ExpMetaType
	pos++
	buf[pos] = dataType
	pos++

	copy(buf[pos:], key)

	return buf
}

//decode the expire 'meta key', the return values are: dataType, key, error
func expDecodeMetaKey(mk []byte) (byte, []byte, error) {
	pos := 0

	if pos+2 > len(mk) || mk[pos] != ExpMetaType {
		return 0, nil, errExpMetaKey
	}

	return mk[pos+1], mk[pos+2:], nil
}

//decode the expire 'time key', the return values are: dataType, key, whenToExpire, error
func expDecodeTimeKey(tk []byte) (byte, []byte, int64, error) {
	pos := 0
	if pos+10 > len(tk) || tk[pos] != ExpTimeType {
		return 0, nil, 0, errExpTimeKey
	}

	return tk[pos+9], tk[pos+10:], int64(binary.BigEndian.Uint64(tk[pos+1:])), nil
}

type expiredMeta struct {
	timeKey []byte
	metaKey []byte
	UTC     int64
}

type expiredMetaBuffer interface {
	Write(*expiredMeta) error
}

type expiration interface {
	// key here should be full key in ns:table:realK
	getRawValueForHeader(ts int64, dt byte, key []byte) ([]byte, error)
	ExpireAt(dt byte, key []byte, rawValue []byte, when int64) (int64, error)
	rawExpireAt(dt byte, key []byte, rawValue []byte, when int64, wb engine.WriteBatch) ([]byte, error)
	// should be called only in read operation
	ttl(ts int64, dt byte, key []byte, rawValue []byte) (int64, error)
	// if in raft write loop should avoid lock, otherwise lock should be used
	// should mark as not expired if the value is not exist
	isExpired(ts int64, dt byte, key []byte, rawValue []byte, useLock bool) (bool, error)
	decodeRawValue(dt byte, rawValue []byte) (*headerMetaValue, error)
	encodeToRawValue(dt byte, h *headerMetaValue) []byte
	delExpire(dt byte, key []byte, rawValue []byte, keepValue bool, wb engine.WriteBatch) ([]byte, error)
	renewOnExpired(ts int64, dt byte, key []byte, oldh *headerMetaValue)
	check(common.ExpiredDataBuffer, chan struct{}) error
	Start()
	Stop()
	Destroy()

	// key here should be key without namespace in table:realK
	encodeToVersionKey(dt byte, h *headerMetaValue, key []byte) []byte
	decodeFromVersionKey(dt byte, vk []byte) ([]byte, int64, error)
}

func (db *RockDB) expire(ts int64, dataType byte, key []byte, rawValue []byte, duration int64) (int64, error) {
	var err error
	if rawValue == nil {
		rawValue, err = db.expiration.getRawValueForHeader(ts, dataType, key)
		if err != nil {
			return 0, err
		}
	}
	return db.expiration.ExpireAt(dataType, key, rawValue, ts/int64(time.Second)+duration)
}

func (db *RockDB) KVTtl(key []byte) (t int64, err error) {
	tn := time.Now().UnixNano()
	v, err := db.expiration.getRawValueForHeader(tn, KVType, key)
	if err != nil {
		return -1, err
	}
	return db.ttl(tn, KVType, key, v)
}

func (db *RockDB) HashTtl(key []byte) (t int64, err error) {
	tn := time.Now().UnixNano()
	v, err := db.expiration.getRawValueForHeader(tn, HashType, key)
	if err != nil {
		return -1, err
	}
	return db.ttl(tn, HashType, key, v)
}

func (db *RockDB) BitTtl(key []byte) (t int64, err error) {
	tn := time.Now().UnixNano()
	v, err := db.expiration.getRawValueForHeader(tn, BitmapType, key)
	if err != nil {
		return -1, err
	}
	return db.ttl(tn, BitmapType, key, v)
}

func (db *RockDB) ListTtl(key []byte) (t int64, err error) {
	tn := time.Now().UnixNano()
	v, err := db.expiration.getRawValueForHeader(tn, ListType, key)
	if err != nil {
		return -1, err
	}
	return db.ttl(tn, ListType, key, v)
}

func (db *RockDB) SetTtl(key []byte) (t int64, err error) {
	tn := time.Now().UnixNano()
	v, err := db.expiration.getRawValueForHeader(tn, SetType, key)
	if err != nil {
		return -1, err
	}
	return db.ttl(tn, SetType, key, v)
}

func (db *RockDB) ZSetTtl(key []byte) (t int64, err error) {
	tn := time.Now().UnixNano()
	v, err := db.expiration.getRawValueForHeader(tn, ZSetType, key)
	if err != nil {
		return -1, err
	}
	return db.ttl(tn, ZSetType, key, v)
}

type TTLChecker struct {
	sync.Mutex

	db       *RockDB
	watching int32
	wg       sync.WaitGroup

	//next check time
	nc int64
}

func newTTLChecker(db *RockDB) *TTLChecker {
	c := &TTLChecker{
		db: db,
		nc: time.Now().Unix(),
	}
	return c
}

func (c *TTLChecker) setNextCheckTime(when int64, force bool) {
	c.Lock()
	if force {
		c.nc = when
	} else if c.nc > when {
		c.nc = when
	}
	c.Unlock()
}

// do not run while iterator or in other db read lock
func (c *TTLChecker) compactTTLMeta() {
	c.db.CompactOldExpireData()
}

func (c *TTLChecker) check(expiredBuf expiredMetaBuffer, stop chan struct{}) (err error) {
	defer func() {
		if e := recover(); e != nil {
			buf := make([]byte, 4096)
			n := runtime.Stack(buf, false)
			buf = buf[0:n]
			dbLog.Errorf("check ttl panic: %s:%v", buf, e)
		}
	}()

	now := time.Now().Unix()

	c.Lock()
	nc := c.nc
	c.Unlock()

	if now < nc {
		return nil
	}

	nc = now + 3600

	minKey := expEncodeTimeKey(NoneType, nil, 0)
	maxKey := expEncodeTimeKey(maxDataType, nil, nc)

	var eCount int64
	var scanned int64
	checkStart := time.Now()

	it, err := c.db.NewDBRangeLimitIterator(minKey, maxKey,
		common.RangeROpen, 0, -1, false)
	if err != nil {
		c.setNextCheckTime(now, false)
		return err
	} else if it == nil {
		c.setNextCheckTime(nc, true)
		return nil
	}
	defer it.Close()

	tableStats := make(map[string]int, 100)
	for ; it.Valid(); it.Next() {
		if scanned%100 == 0 {
			select {
			case <-stop:
				nc = now
				break
			default:
			}
		}
		tk := it.Key()
		mk := it.Value()

		if tk == nil {
			continue
		}

		dt, k, nt, dErr := expDecodeTimeKey(tk)
		if dErr != nil {
			continue
		}

		scanned += 1
		if scanned == 1 {
			//log the first scanned key
			dbLog.Debugf("ttl check start at key:[%s] of type:%s whose expire time is: %s", string(k),
				TypeName[dt], time.Unix(nt, 0).Format(logTimeFormatStr))
		}

		if nt > now {
			//the next ttl check time is nt!
			nc = nt
			dbLog.Debugf("ttl check end at key:[%s] of type:%s whose expire time is: %s", string(k),
				TypeName[dt], time.Unix(nt, 0).Format(logTimeFormatStr))
			break
		}

		eCount += 1

		err = expiredBuf.Write(&expiredMeta{timeKey: tk, metaKey: mk, UTC: nt})
		if err != nil {
			nc = now
			break
		}
		table, _, inerr := extractTableFromRedisKey(k)
		if inerr == nil && len(tableStats) < 100 {
			n, _ := tableStats[string(table)]
			n++
			tableStats[string(table)] = n
		}
	}

	c.setNextCheckTime(nc, true)

	checkCost := time.Since(checkStart)
	if dbLog.Level() >= common.LOG_DEBUG || eCount > 10000 || checkCost >= time.Second {
		dbLog.Infof("[%d/%d] keys have expired during ttl checking, cost:%s, tables: %v", eCount, scanned, checkCost, len(tableStats))
		// only log the stats if the expired data is in small tables (which means most are in the same table)
		if len(tableStats) < 10 || dbLog.Level() >= common.LOG_DEBUG {
			dbLog.Infof("expired table stats %v", tableStats)
		}
		if checkCost > time.Minute/2 {
			// too long scan, maybe compact to reduce the cpu cost
			err = errTTLCheckTooLong
		}
	}

	return err
}

redpajama_set_name: RedPajamaGithub


text:
Hesperia School Police Responded to Report of a Student with a Gun
HESPERIA-(VVNG.com): Just before 8:00 a.m. units from the Hesperia School Police were dispatched to Mojave High School on the 16300 block of Lemon street for the report of a student with a gun.
Per scanner traffic the suspect was a Hispanic man, that was 5'5" tall with a thin build.
The CHP helicopter was called to assist in the search for the unidentified suspect, who was reportedly wearing a dark colored hooded jacket. The CHP helicopter located the suspect within minutes on the northeast corner of the campus and just before 8:15 a.m. the suspect was detained without incident.
According to Hesperia Unified School district officials the student (suspect) was cleared of any wrongdoing and no weapon was ever found. There were no reported injuries and the school was not placed on lockdown despite the report.
Victor Valley News reached out to the Hesperia School Police, but they were not available for comment. Information will be updated as it becomes available.


CYBRI provides access to elite cybersecurity professionals in the U.S. to help businesses protect their integrity and reputation.
CYBRI experts are experienced CISOs, white hat ethical hackers, cybersecurity researchers, and data privacy specialists available to help business in the US and globally with their immediate and long-term cybersecurity and data privacy needs. Post your project on the CYBRI network and receive bids from our elite pool of cybersecurity experts.
Our platform allows businesses to access cybersecurity expertise on demand.
Easily describe your project using our simple process designed to help explain your needs in a business-like manner. Once your project is submitted, it will be shared with CYBRI's network.
Proposals from our cybersecurity experts will be sent to you via email and will be accessible at your convenience in a secure dashboard. We keep things simple and transparent.
Communicate directly using our secure messaging system to keep tasks and progress in order. All if your tasks, deliverables, documents, and notes will be accessible to you at any time in CYBRI's easy-to-use customer dashboard.
In today's world, businesses need to have strong cyber posture. Understanding your cyber hygiene is critical, especially when conducting business with larger and/or regulated entities. Let's be realistic — no company wants to end up in the news about a cybersecurity breach.
Work with highly vetted cybersecurity professionals who ensure businesses are covered on all cybersecurity compliance needs. HIPPA, NIST, PCI, SOC2.
CYBRI has the best in-class ethical hackers and penetration testers that assess your internal and external threats. Effectively test your web and mobile apps, networks and servers, clouds, and APIs.
91 percent of all threats come from your employees. Invest in educating your employees about the latest threats and techniques that are being used by the hackers.
Submit a project or schedule a call.
Interested in Becoming a CYBRI Expert?


Evolution of Metabolic Hormones for Therapeutic Purposes by Richard DiMarchi, Ph.D.
Richard DiMarchi, Ph.D., from the Department of Chemistry and the Linda and Jack Gill Center at Indiana University, will present a lecture entitled: Evolution of Metabolic Hormones for Therapeutic Purposes.
Abstract: The epidemic of diabetes and its associated comorbidities represents a medicinal challenge that warrants brouad molecular diversity. From the earliest demonstration with lispro-insulin to the most recent discovery of single molecule, mixed incretin agonists we have pursued the discovery of chemically optimized macromolecules directed at the successful management of diabetes, obesity and related diseases. The integrated biology of these peptides, proteins, and nuclear hormones has provided a library of drug candidates replicated across multiple academic and commercial laboratories that have advanced to human clinical studies in matabolic diseases. We have coined the term "chemical biotechnology" to reflect the integration of classical small and large molecule-based pharmacology, while advancing the chemical methodology in synthesis of complex macromolecules. The integrated biology of these peptides, proteins and nuclear hormones has provided a library of drug candidates replicated across multiple academic and commercial laboratories that have advanced to human clinical studies in metabolic diseases.


text:
Ismail Sabri outlines which shops, businesses can stay open during MCO 2.0, and which ones can't
BY EMMANUEL SANTA MARIA CHIN
Ismail Sabri explained that staff within these essential services must first have their companies registered to operate during the MCO. — Bernama pic
KUALA LUMPUR, Jan 12 — A majority of businesses, eateries, and shops will be allowed to operate from 6am to 8pm daily under the latest implementation of the movement control order (MCO), Datuk Seri Ismail Sabri Yaakob announced today.
The senior minister explained that businesses subject to the 14-hour window during the MCO are restaurants and eateries, food trucks, roadside and mobile vendors and food kiosks, food courts and hawker centres, including sundry and convenience shops.
Shops selling daily essentials, vets and animal food shops, laundromats, pharmacies, and even food delivery and drive-through eateries will also be subject to the 6am-8pm rule during the MCO's 14 days, Ismail Sabri said.
"Hospitals and clinics will be allowed to operate 24 hours," he said.
Petrol kiosks will be allowed to operate from 6am to 10pm with those on expressways allowed to open round the clock.
He said that daily markets are allowed to operate from 7am to 2pm, while wholesale markets will be allowed to open from 12am to 6am and from 11am to 4pm.
Ismail Sabri explained that staff within these essential services must first have their companies registered to operate during the MCO, and to make sure all employees are equipped with the adequate company permission slips and staff cards to present to authorities at road blocks.
"Even movements involving official government business must be accompanied by verification documents from the employers," he said.
Among the activities banned during the MCO include night markets and bazaars, clothes stores, self-service laundromats, optical and spectacles shops, barbers and hair salons, spas and reflexology centres.
Social events that would attract a crowd, such as official functions both in the government and private sector, weddings, engagements parties, anniversaries, religious events, birthday parties, retreats and other similar gatherings are also banned for the next 14 days.
Also on the negative list are tuition, music, dance, art, religious (mengaji) and language classes, along with activities in nightclubs, indoor theme parks and indoor playgrounds, karaoke centres, and cinemas.
"Concerts and 'live' events are also not allowed," Ismail Sabri said.
Other banned activities include tourism, sports and recreational activities and events, meetings, incentives, conferences and exhibitions (MICE).
Ismail Sabri said that unlike previous SOPs, MICE and social events will also be barred in states under the conditional MCO (CMCO), such as conferences and weddings.
"As for areas under the CMCO, non-contact sports involving no more than 10 people like jogging, cycling and others will be allowed while following the strict SOPs," he said.
He added that Perlis and Sarawak, the only two states under the most lenient recovery MCO (RMCO) can stick to previous SOPs already announced, with one new regulation that bans interstate travelling in and out of the state.


Have Fun and Discover the Secrets of Rajasthan with a Rajasthan Tour Package Among all of the states in India, Rajasthan is considered one f the most amazing. The state is popular for being a living place of kings, thus people are coming from all parts of the globe to see the majestic forts and mahals of the kings. Jaipur, Jodhpur, Bikaner, Udaipur, Chittorgarh, and Jaisalmer are the cities in Rajasthan that is considered as the centers of attraction which is the reason why they are all included in the Rajasthan tour package. The Pink city which is the Jaipur is the capital city of Rajasthan and it is just close to Delhi, that's the reason why tourists come there through Delhi. As said above, the state is considered as a royal state as it has been a home of kings, that's why a lot of people are curious and want to have a special Rajasthan tour package in order to explore and experience the royal living here. In Rajasthan, people are wearing colorful dresses and their food is really attractive and delicious. So, if they want to have a look with the architecture of palaces and forts that cannot be seen anywhere else in the world, choose the Rajasthan tour packages offering to visit all the cities of the royal state. Some of the attractive place in Rajasthan that you can visit are the places of Amber Fort, Lake Pichola Udaipur, Camel Safari at Jaisalmer, Rat Temple at Bikaner, Camel Breeding farm at Bikaner, City Palace at Jaipur, Albert Hall Museum, Hawa Mahal, Jantar Mantar, Nahargarh Fort, Udai Sagar Lake, Golden Fort, Jain Temples and Havelis, Lalgarh Palace. As these places are all included in Rajasthan tour packages, these places creates a stamp in the heart of the people that have visited them that they want to visit India again and again.
Art, culture, craft, king size living, nature, variety of foods, and deserts are all the featured here. You can have amazing experience like camel rides at Thar Desert, boating at several lakes, and fold dance of villagers. Time flies so fast in this world that you want to experience Rajasthan tour package again. The culture, music, and tradition in Rajasthan are majestic too aside from having worth visiting places that are all included in Rajasthan tour packages. Getting around with the music, dance, and food of Raajasthan, which vary as you move from one city to another is the best way to enjoy and feel the culture of the state.
Visiting the most adorable shopping places in the state is included in Rajasthan tour packages. Rajasthan dresses are worldwide popular.


text:
Coming Soon to Gaza: Lashes in Criminal Code
iranaware
Hamas taking another step towards the full implementation of Sharia law in Gaza, will introduce lashes for certain offenses.
By Dalit Halevi
Hamas is taking another step towards the full implementation of strict Islamic Sharia law in Gaza, and is planning to introduce a penalty of lashes for certain criminal offenses.
Nafez Al-Madhoun, the secretary of Hamas's parliament in Gaza, said on Tuesday that the government is working on passing a new law pertaining to lashes. Speaking in an interview with a local newspaper, Madhoun said that the provisions of the new law will include a range of between 80 lashes for major offenses to 20 lashes for minor crimes.
Madhoun further explained that a change in the Penal Code to include lashes is required, in light of the reality where the current law does not deter criminals, who view the Gaza prisons as a place for a vacation.
On Land and in the Air, This Woman Proudly Defends Israel
March 9, 2014 / Mėir Weiss/z
On Land and in the Air, This Woman Proudly Defends Israel.


text:
Berta Cáceres murder linked to Honduras elites
Honduran authorities are not prosecuting the alleged intellectual authors of the assassination, leaving the criminal network that directed the environmental activist murder still very much intact. Español Português
Parker Asmann
Berta Cáceres was recognized internationally for her environmental activism in Honduras.
Via InSight Crime
Recently published messages have offered fresh insight into the plot to murder renowned environmental activist Berta Cáceres in Honduras, laying bare how authorities have failed to bring the alleged intellectual authors of the crime to justice.
Private call logs, SMS, and WhatsApp messages unearthed by the Honduran Public Prosecutor's Office revealed that the hit squad "communicated through a compartmentalized chain that reached the highest ranks of leadership" of Desarrollos Energéticos SA (DESA), the company building the Agua Zarca hydroelectric dam, the Intercept reported on December 21.
Cáceres, who was awarded the prestigious Goldman Environmental Prize in 2015, had long protested the construction of the dam, which threatened the livelihood of the Indigenous Lenca community living along the Gualcarque River. The activist was later shot dead in March of 2016 at her home in La Esperanza, in southwest Honduras.
One of the group chats included former DESA Executive Director Roberto David Castillo Mejía and Chief Financial Officer Daniel Atala Midence, as well as DESA board members José Eduardo Atala Zablah and Pedro Atala Zablah. The Atala Zablahs are one of Honduras' most powerful families with close ties to the country's government and financial elites.
"It's them or us," DESA board member Pedro Atala Zablah said in a message to the group in October of 2015, in reference to the Civic Council of Popular and Indigenous Organizations of Honduras (Consejo Cívico de Organizaciones Populares e Indígenas de Honduras – COPINH), the organization that Cáceres founded and whose members opposed the dam.
"Let's send a message that nothing will be easy for those SOBs," he wrote.
An attorney for Daniel Atala Midence and Pedro and José Eduardo Atala Zablah told the Intercept that their clients "completely deny any participation in this unfortunate crime." None of the men have been arrested or face criminal charges.
Cáceres' murder wasn't a spur-of-the-moment decision,
Seven of the eight men accused of carrying out Caceres' killing — among them US-trained former military officials and DESA employees — were found guilty in November of 2018 and later sentenced to serve between 30 and 50 years in jail.
When delivering the verdict against Caceres' killers, the court ruled that DESA executives had ordered Cáceres' murder because her efforts had caused the company to suffer financial losses and delays to the project.
In March of 2018, Honduran authorities arrested Castillo Mejía, DESA's executive director at the time of Cáceres' murder, for his role as an alleged intellectual author. However, he is still awaiting trial amid a number of delays and other irregularities in the case. A Honduran law on pretrial detention could lead to Castillo Mejía's release if his case is not decided by March of 2020. He has denied all charges against him.
InSight Crime Analysis
Cáceres' murder wasn't a spur-of-the-moment decision, it was the "culmination of years of coordinated corruption and violence," according to the Intercept. While her shooters are behind bars, Honduran authorities seem less keen on prosecuting the alleged intellectual authors of the assassination, leaving the criminal network that directed her murder still very much intact.
For more than a year, DESA executives methodically planned to take down Cáceres and her organization by systematically co-opting police, government officials and the media, according to the Intercept.
In 2013, when the Honduran military murdered COPINH member Tomás García during a protest of the Agua Zarca dam's construction, Atala Midence and Castillo Mejía quickly plotted to "control the media narrative," using bribes to reporters in order to portray the deadly incident as a "confrontation over opposition to the dam," according to the Intercept.
"Pay the reporter from HCH," Castillo Mejía told Atala Midence in reference to the local news station HCH Televisión Digital. "1,000 lempiras [around $40] for last week … and right now we can give him another 1,000."
Those that allegedly plotted Cáceres' murder also reportedly relied on allies in the local police to intimidate community members protesting the dam's construction.
"We thank you for the support that you gave us yesterday, the Copinhnes saw the presence of the National Police … and they were afraid to cross the river," read one message Castillo Mejía sent to a police chief that was later shared in the group chat of DESA board members, executives and other employees.
After Cáceres' murder, company executives leaned on their powerful political allies, such as Security Minister Julian Pacheco, who, according to the Intercept, promised Pedro Atala Zablah just days after the murder that it would be classified as a "crime of passion" to divert unwanted attention away from the company.
The messages suggest that those involved in the plot to murder Cáceres knew that they had enough friends in high places to ensure that the odds of them facing justice were slim to none. They spoke clearly of their intentions in messages, discussing details of the "mission," bribes to be paid and weapons to be exchanged to carry out the crime.
As things stand now, the elites that felt they could deliberately plan and carry out a high-profile murder with impunity were completely right.
This article was originally published in InsightCrime. Read the original here.
Lo último de democraciaAbierta
Citizen diplomacy for Argentina's relationship with Brazil
Written by: Juan Gabriel Tokatlian All articles by: Juan Gabriel Tokatlian
The spectacle of corruption in Angola
Written by: Stephen Chan All articles by: Stephen Chan
What cards, if any, can the UK play in Latin America after Brexit?
Written by: Anna Grugel Smith All articles by: Anna Grugel Smith
Colombia: A country used to violence
Written by: Daniela Sánchez All articles by: Daniela Sánchez
View all in democraciaAbierta


This space-dyed Chenille Scarf is a perfect accessory to complement whatever you are wearing, indoors or out. Handwoven on the backstrap loom of hand-dyed luxurious rayon chenille. Warm and cozy, a great alternative for those sensitive to wool. Since each is individually hand-dyed, colors will vary. Great for men, too.


Here we present Singularity Hub, a framework to build and deploy Singularity containers for mobility of compute, and the singularity-python software with novel metrics for assessing reproducibility of such containers. Singularity containers make it possible for scientists and developers to package reproducible software, and Singularity Hub adds automation to this workflow by building, capturing metadata for, visualizing, and serving containers programmatically. Our novel metrics, based on custom filters of content hashes of container contents, allow for comparison of an entire container, including operating system, custom software, and metadata. First we will review Singularity Hub's primary use cases and how the infrastructure has been designed to support modern, common workflows. Next, we conduct three analyses to demonstrate build consistency, reproducibility metric and performance and interpretability, and potential for discovery. This is the first effort to demonstrate a rigorous assessment of measurable similarity between containers and operating systems. We provide these capabilities within Singularity Hub, as well as the source software singularity-python that provides the underlying functionality. Singularity Hub is available at https://singularity-hub.org, and we are excited to provide it as an openly available platform for building, and deploying scientific containers.
Copyright: © 2017 Sochat et al. This is an open access article distributed under the terms of the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original author and source are credited.
Data Availability: The Singularity Python software is available at https://www.github.com/singularityware/singularity-python and Singularity Hub is available for use at https://www.singularity-hub.org.
Funding: Vanessa Sochat is supported by Stanford Research Computing and the School of Medicine. The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.
The modern scientist is challenged with the responsibilities of having expertise in a field, procuring funding, teaching, and publishing to maintain a career. The publication that these scientists produce are implicitly expected to be "reproducible", meaning that they document and make available the methods, data, and tools necessary to repeat experiments and reliably produce similar or identical results. The "reproducibility crisis" [1–3] revealed that a large proportion of publications were not reproducible by other trained scientists. What followed was powerful, proactive action: an investigation and discussion about standards for publication, data sharing, and dissemination of code and tools for reproducible science [1–6].
The scientific community continues to teach and advocate for common practices from software development [7–10] such as continuous testing and version control of code, and storage and sharing of standardized data structures [4, 5, 9, 11–13] to improve reproducibility. Additional assistance is often provided by universities and research institutes by teams of staff dedicated to supporting research computing, but this support is clearly not enough. Arguably, if scientists were afforded tools that enforced reproducible practices that were both easy and enjoyable to use, the difficulties of reproducible research could be ameliorated.
During this same period of time that the scientific community was reflecting on the reproducibility of its work, the enterprise software community was making rapid progress in developing linux containers [4, 14]. Linux containers enable developers to package software dependencies in portable environments that can be seamlessly deployed on different systems. This technology was needed by the HPC (high performance computing) communities, and an inability to provide one of these technologies, Docker , in a secure environment led to the development of Singularity containers  for scientific compute. HPC communities have, and continue to, bring Singularity to their clusters, meaning that a scientist can package his or her work in a container and run it on any system with Singularity installed, no matter whether that system is a personal computer, a local research cluster, or a cloud environment. The typical workflow entails the user developing the container locally or in an environment where he or she has sudo privileges (see Figure 1 of ) and then moving the ready-to-use container to the intended location of use. Here we see a potential bottleneck in the workflow: these containers are too big to host using version control (e.g., Github), and if users can not build a container on the same system where they intend to deploy it, then manually transfer is required, and this becomes quickly burdensome.
Singularity Hub is a modern solution for scientists and developers to quickly build and deploy containers. By way of using version control and webhooks [5, 16], a user is afforded automated container builds simply by pushing a set of instructions to a version controlled repository. Singularity Hub captures metadata about the container and its build, and serves this information, along with the containers themselves, from an interactive web interface and via a RESTful application program interface (API) . The containers are integrated seamlessly into the Singularity  command line software, and thus programmatically available for scaled science. This paper will proceed as follows. We will first describe the goals of Singularity Hub, several use cases, and its infrastructure. Next, we will move the discussion to the algorithms provided by the singularity-python  software. This robust set of reproducibility metrics has promise to drive reproducible research, and organization of the container ecosystem. For the first time, we study the architecture and metadata about the contents of a container, and use this rich set of features assess the similarity of entire operating systems. Using different levels of reproducibility criteria afforded by the metrics, we propose increased focus on a domain of operating system science.
This process is shown in Fig 1. For the remainder of this overview, we will provide examples using a container in a Github repository under username vsoch called hello-world. The Github user vsoch would connect the repository hello-world to Singularity Hub, and in doing so would create a namespace corresponding to a group of images (a collection) associated with the repository. This collection would be called vsoch/hello-world to indicate the user and repository from which it is based. The user then develops her code. Each update, done by way of a push  to generate a new version (what Github calls a commit , would send a message to Singularity Hub to build a new container corresponding to the updated code. If the user vsoch wanted to provide multiple different builds in the same repository, she would do that by way of different extensions to the Singularity files in the repository. The user is allowed to have one private repository, meaning a collection of builds that is only accessible to him or her. The choice to allow a user to not share his or her container is done intentionally to be in line with one of Singularity Hub's goals to support reproducible science, discussed next.
Fig 1. Singularity Hub user workflow.
The user creates a specification file to build an image (top left), and pushes this to a version controlled repository (top right). The repository is connected to Singularity Hub by way of a webhook, which sets up and sends a job to a queue to run in the cloud (bottom right). After a series of checks for job priority, the job is deployed to create an instance "builder" that clones the repository, builds the image from the specification file, and sends the completed image to cloud storage (bottom left). Complete metadata is sent back to Singularity Hub to alert the user of the build completion, and the image is available for use by way of the Singularity software and Singularity Hub API.
The application and supporting infrastructure were developed with the goals of making containers moveable, transparent, their builds customizable, and their deployment scalable. Tools are provided that make it easy to compare and assess the reproducibility of containers. All visualizations and functions to build and compare containers provided by Singularity Hub are provided to the user. This open standard and these functions support the larger underlying goal of encouraging data sharing and reproducible science.
In 1, the user pulls the latest image built from the master branch of vsoch/hello-world. The image file is downloaded to the present working directory or a user-specified cache. In 2, the user chooses to run a particular version of the container, the image associated with the tag devel that corresponds to a Singularity recipe with extension devel (Singularity.devel). The "run" command will, by default, run an executable that the user has defined to be an entry point to the container . In 3, the user chooses to run the latest version of a container, and in 4 the user chooses instead to shell into the container to work on the command line. Finally in 5 the user sends (executes) a command for the container to run. For commands 2-5, the container is downloaded to the image cache defined by the user or system administrator for the Singularity software.
For many years, our primary way of interacting with containers and operating systems on remote servers that do not support display tunneling has been by way of a command line. If the container is running, the user can "see" what it contains by shelling into it, and then "mapping" out its contents by using the commands "ls", and "cd" to list files and change directories, respectively. While providing a build file gives the user somewhat of a look inside of a container by describing the changes made to the base operating system, it isn't comparable to inspecting a system via software such as a File Manager [22–24]. Singularity Hub aims to be transparent in that it gives the user an interactive visualization to see the inside of every container, and to compare containers.
Fig 2. Container tree: Each container is stored with a list of folders and files that render into an interactive tree for the user, both in the Singularity Hub web interface, and on the user's local command line using the Singularity Hub software.
This calculation is extended to provide an immediate comparison of the latest containers in Singularity Hub, a "Collection Tree" (Fig 3), allowing the researcher to find containers with similar software. The data structure to generate the visualization is re-generated on a daily basis, and all data archived to provide a rich dataset of a changing container ecosystem for future analysis. Finally, the software provides simple functions to show similar and different files between any two containers, and plots that show the similarity of each container to a set of common base operating systems (Fig 4). A suggested use case would be to find similar containers across Singularity Hub using the Collection Tree view, and then drill deeper with these functions. Importantly, all of these functions and visualizations are available for the user to run and generate locally for his or her research or personal interest by way of the singularity-python  software.
Fig 3. The collection tree provides the researcher with an immediate comparison of the latest version of all containers across Singularity Hub, an easy way to find similar containers using the software and files inside as the metric for comparison.
In the example above, a gray node represents a group of containers, and a red node a single container. The user can hover over a node to see all the containers that are represented.
Fig 4. Operating system estimation: Each container is compared to a set of 46 operating systems, including multiple versions of Ubuntu, Centos, Debian, Opensuse, Alpine, Busybox, Fedora, and others.
In the example above, the user is highlighting one of the columns to inspect the score, and the build was for a container bootstrapping a Centos 6 image.
Early in the development of Singularity Hub, we identified a need that a user may want to customize the builder. For this reason, the builder images are variable within the application. The default behavior of the build is to deploy an instance of size 50GB, however the user can ask the builder to deploy a larger sized instance if more hard disk is needed. We intend to extend this level of customization based on feedback from our users, and allow for custom storage if there is interest. While the current application is deployed on Google Cloud, the code base is modular to make it ready for extension to other cloud environments.
The Singularity software uses caching and other strategies  to allow for the scaling of image deployment. For a typical use case, the user would make a call to the Singularity Hub endpoint (e.g., shub://) and the image would be cached and reused. In the case that one or more images are needed for download concurrently, the storage on Google Cloud was chosen to optimize this functionality. The storage is separate from the web application and image downloads do not drain the resources of the web application server.
The web application, database to serve it, and storage for images are protected under Google Cloud Default application credentials , which are available to the server but not exposed in the web application itself. The database is replicated with a setup called hot standby mode  that ensures that all data is mirrored, and an identical instance database available given any failure to the main application. The database, the replication, along with the images and associated metadata are all stored separately and with redundancy, so any failure in one component of the application does not mean loss of all components. The use of Github for version control of build files ensures that, given that some catastrophic event did occur, they could easily be rebuilt by way of rebuilding the files.
Singularity Hub is a Dockerized  application, running a secure nginx  web server to serve a Python-based (Django)  application. The RESTful API follows the Swagger standard . The user is provided with a user guide, a search interface for collections, and a table that lists container collections that is sortable by downloads and user "favorite" stars. Within each container collection is a table of builds, each of which has a tab with example usage (Commands), a comprehensive, colored coded and filterable build log (Log), an interactive bar chart that shows the calculated similarity scores of each build against common operating systems (Plots), a list of labels and internal tags (e.g., file extension counts) derived for the container, and user generated interactive tutorials (Asciinema, YouTube, or external documentation). Across the site, each container build has a small plus (+) button that affords the build to be added to the user's "Saved Containers", a drawer on the bottom of the screen where a user can save containers, akin to a cart. Once in the drawer, the user can select containers to view and compare interactively to other containers. This function takes advantage of local storage in the user's browser, and we hope to extend it to allow the user to perform more operations on single and sets of containers.
A maximum of 15 active and pending builds is allowed, and beyond this number additional requests are ignored until the current queue is processed.
We tested this queue during our reproducibility demonstration (Reproducibility Demonstration) and verified that each collection only built one container at a time, pushing builds to exceed more than 15 in pending disabled the collection, and triggering the builder to exceed a rate of 100 per hour also disabled the collection.
The Singularity Hub builders are cloud images that are deployed into instances on demand, and the build is done in an isolated environment from the host. Each is essentially an operating system image, and the most up to date are currently configured with Ubuntu 16.04 LTS and Singularity version 2.4. Each builder is stored with metadata associated to a build family, which generally specifies the builder name, software version, and image size (e.g., singularity-builder-2-4-50gb). In this manner, images of size 50gb and 100gb are provided for each official release (e.g., version 2.4) of the Singularity software. Unless there is a security risk discovered in an older version, these images will be maintained and available for the user to choose from to allow for backwards compatibility as the software develops.
The scripts deployed to the builders to perform the build are sent to the builders by way of the Google metadata API , and the programmatic specification of a script allows users to customize the build process to their needs. Other cloud services (e.g., Amazon Web Services) have similar APIs that could also be used in this manner.
The builders collect various metadata about each container (Table 1) including container size, build time, estimated operating system, software and services, container labels and environment, file extension counts, the build specification file "Singularity", and a complete build log. The metadata is sent to object storage with the containers, and back to the Singularity Hub database, where the user can explore it interactively. Some metrics (e.g., container size and build time) are useful for administrators and users to understand how to optimally store containers, and expected times for building. Other metrics (e.g., file extensions and estimated operating system) have less obvious immediate value, have potential to be a rich set of data for better understanding of scientific software (see Discussion). We provide details about different metrics below, and in Table 1.
The container size is calculated at the end of the container build, and added as metadata to the container itself. It is extracted along with other environment and labels with the "inspect" command applied to the image before sending to storage.
2.6.2 Estimated operating system and software.
The Singularity Builder uses the singularity-python software to calculate an estimated base operating system. Once this is done, the files in the base can be subtracted from the list to leave a meaningful set of additions that have been made from the base of the container. This set, akin to a "diff" between two files , is used to count file extensions from files relevant to the additions to the container. If the user has installed internally modular applications called Standard Container Integration Format (SCI-F) apps  metadata about the apps is extracted as well.
An essential component of developing a scientific workflow is debugging. Given that Singularity Hub removes the burden of needing to build the container locally, it also takes on the burden of sending back the alarm given that something goes wrong. To meet this need, the Singularity Hub builder uses standard Python logging  to print metadata and all command line output to a log file on the builder. The process to complete the build and send the log back to Singularity Hub is executed as a different process from the building command to ensure that regardless of what happens, a signal gets sent back to Singularity Hub to update the user with the status of the build, whether that be a notification that the job completed successfully or that it did not. To make it easy for the user to filter down to key error lines before trying the build again, Singularity Hub color codes the log lines based on the kind of message (debug, error, warning, info, and download) such that the user can click corresponding filter buttons to focus on content of interest. The user can also download the log for further inspection.
The infrastructure and underlying data structures and technologies have been designed in a way to incentivize reproducible scientific practice.
One of the biggest challenges in the quest for reproducibility is encouraging researchers to share data and code [36–38]. The application supports private collections, meaning that only the owner has access to it, in the case that a container is under development and needs to be kept private before it is published. A user can also "freeze" a container, which is a guarantee to other users that it will not be deleted. However, to reinforce general reproducibility of analysis containers, the user is only allowed one private collection. All users are allowed to create as many collections as desired, coinciding with one Github repository each, and we will only change this standard if it becomes abused.
Singularity Hub provides version control for all containers by way of Github. Each build is linked directly to a particular commit, build specification file, and branch of a Github repository, and the requirement of a build specification file (the file "Singularity") is another choice to ensure that the creation of containers carries a level of transparency. Github provides another layer of security in that an exact container version can always be reproduced from its desired build file, given that all dependencies that are downloaded (and not provided in the repository) remain available.
Table 2. Levels of reproducibility.
The filter levels are described in Table 1, and the algorithm to apply them described in the next section.
The filtering algorithm, for any specified level, considers each of these specifications, and toward the goal of making it usable for the user without sudo privileges, also takes the file permissions into account when further assessment is needed. The algorithm proceeds as follows, and is illustrated in Fig 5). Each container has its contents streamed into an in-memory tar. For each file in the tar objects, called "members", the md5 hash is calculated using hashlib . These hashes are for the file objects, including the timestamps and metadata for their respective file. The final lists of files, along with their hashes, are then compared between the two containers. Files that are unique to each container (present in one but not the other, represented in yellow and blue sections of Fig 5) are considered to be in the difference of the two sets. Within the set intersection (Shared Files), the md5 sums of the files are compared. Files that match are called "same" (green). Files that are not the same on the level of the file hash are taken to the next level of assessment, which first looks at root ownership. If the file is not root owned, then cat  is used to extract the bytes content, and we generate two hashes for final comparison. In the case of root ownership, we cannot use cat to extract the contents, and make the final comparison based on the size of the file (size heuristic). Equivalent sizes are considered equal, and the file is added to same, and different sizes classify the file as belonging to different. In the case of a non-root owned file, we generate a hash from the bytes, and then again compare the hashes, for placement into respective groups (Fig 5).
Fig 5. Reproducibility assessment algorithm: A comparison between two containers comes down to comparing the members of the tar stream first based on an md5sum of the file member itself, and then in the case of a mismatch, looking at the content hash (non-root owned) or using a size heuristic (root owned).
The final counts of files of overlapping versus different files are then used to calculate an information coefficient using a subset of files particular to a filter (Levels of Reproducibility of Containers) to describe similarity of the two containers.
These criteria are programmatically accessible by way of data structures included with the singularity-python package , and customizable by the user. The software can either generate hashes for all files pertaining to a level (in the example above to compare two containers) or add all files to one summarized hash to describe a single container.
Functions are provided to assess two containers, or to derive data structures with hashes, sizes, and information about root ownership. This final function is intended for those users who are interested in using the software for their own research about reproducible software. We provide examples and the complete software  for this use case.
To demonstrate the ability of Singularity Hub to build images at scale, we selected a subset of scientific analyses that had Singularity containers built for previous work (Table 3) and used the web interface to build them automatically on Singularity Hub. The containers include a standard "Hello World" example (vsochsingularity-hello-world), a more robust machine learning prediction tool for physics (researchapps/quantum_state_diffusion) and a published clinical algorithm to predict pulmonary embolism from radiology reports (vsoch/pe-predictive) [43, 44]. For each container, we wrote a simple python script (included with the code in the respective repositories), to make a trivial change to an echo statement in the build file and automatically push to Github to trigger a new build. We did this 100 times per container, with a delay (10, 25, and 30 minutes for each analysis container group, respectively) between pushes to ensure no more than 15 pending containers at once. For each of these builds, our goal is to assess consistency of the build itself. If containers are built consistently, we would expect to see no significant differences in the sizes of our containers, which are estimated by the builders by first building the image into a folder. We would also expect to see small variation in build time (the time from the start to finish of the build, not including time to initialize and shutdown the builder) likely due to instance specific variables like network connectivity and latency.
Table 3. Analysis repository collections.
For assessment of build consistency, ipython notebooks and scripts used for the assessment are provided as examples with the Singularity Python software .
To assess our reproducibility metrics, we would want to demonstrate that the levels can accurately measure known criteria about different sets of containers for which we know some level of ground truth (Ground Truth Assessment), that container scores produced by the levels represent a humanly interpretable range between not similar at all (0.0) and completely identical (1.0) (Metric Interpretability), and that the metrics can be used for new discoveries and comparisons between operating systems that were not previously possible (Potential Assessment).
Singularity Hub Replicates: These containers represent an image built from an equivalent build specification file, one hundred times, on different hosts (each being a Singularity Hub cloud builder). Specifically, we used the vsoch/singularity-hello-world  collection mentioned previously (Build Consistency). We would expect a single container compared against the others in the set to be assessed as equal on the levels of RUNSCRIPT, LABELS, ENVIRONMENT, BASE, and REPLICATE, but different on the level IDENTICAL.
Local Replicates: These images represent an image built equivalently from the same build file, but on the same host. We used an equivalently simply build specification file, and built these images on a local machine with the same operating system as the cloud builders (Ubuntu 16.04). We would equivalently expect any image from this set assessed as equal on the levels of RUNSCRIPT, LABELS, ENVIRONMENT, BASE, and REPLICATE, and different on the level IDENTICAL, however we would expect these images to have a higher similarity score on this last level by way of sharing the same host, which would mean more shared mounts, and cached layers used to generate the images.
Clones: We selected one image from the first Singularity Hub Replicates group to download one hundred times to asses our strictest level of comparison, IDENTICAL. The clone images should have the same summary hash on every level of comparison.
For each of these containers, we conduct an analysis to assess metric interpretability as follows. We define C1 as the container that has all files present for the operating system. We define C2 as a separate container with the same operating system, but with a portion of files removed. We define L as a list of files in the full container, sorted by the time-stamp from oldest to newest. Given a container has a total of M files, we calculate the comparison between C1 and C2 for a range of N = 0:M across reproducibility levels, removing file in L at index N at each step. This comes down to removing the newest files first to generate a slowly changing gradient of similarity that should, if the metrics and methods are sound, start at 1.0 (a comparison between two identical file systems each with M files) and finish at 0.0 (a comparison between a full operating system with M files and an empty container). We would expect the scores for the reproducibility levels assessing the content of specific files (RUNSCRIPT, and LABELS) to remain constant until the files are removed from the container (which happens almost immediately given sorting based on time-stamp), and we would expect the levels REPLICATE, BASE, and IDENTICAL to slowly decrease in similarity as files are removed.
Finally, we would want to show that the reproducibility metrics have value to provide new insights about containers, and allow for comparison of unlike operating systems, which was not previously common practice. We were also interested in assessing how well our Singularity Hub comparison heuristic (Container Trees and Comparisons) that used file paths alone reflected the more robust metric (Assessing Levels of Reproducibility) that also accounted for hashes. Toward this goal, we computed pairwise comparisons on the level of REPLICATE for all publicly available scientific container in Singularity Hub. We used representational similarity analysis  to compare this matrix of similarity scores to one generated with our similarity heuristic. Similarity of these two matrices would suggest that the comparison of file paths alone can be useful to reflect the more robust reproducibility metrics. This similarity matrix would also allow us to see commonalities between the scientific containers that are not readily apparent.
For all analyses above that required Singularity Hub images, we used the Singularity Hub API via the singularity-python software to download container images and metadata. For analyses that required local builds, we used this same software as a wrapper to the command line Singularity software . The reproducibility assessment functions were provided in the reproduce module within singularity-python.
If containers are built consistently, we would expect to see no significant differences in the sizes of our containers, and this turned out to be the case. For each of our containers builds, all 100 builds generated images of the same size (80, 120, and 75 GB for each, Table 4) and while there was some variance in build time, when assessed by a 1-sample T-test there were no values that different significantly from the mean (p = 1.0, T-statistic = 1 for all builds). A summary of our findings for build metrics is included in Table 4, and an ipython notebook for generating and viewing plots of the result is available .
Singularity Hub Replicates: Using a set of 100 containers each generated with separate Singularity Hub builders for the vsoch/singularity-hello-world collection, we compared a randomly selected container against the rest for the reproducibility levels RUNSCRIPT, ENVIRONMENT, BASE, and REPLICATE (S1 Table). In order to trigger the builders, we had to change a trivial space in the runscript to make a Github commit, and were pleased to see this reflected in the results. For half of the containers with the equivalent runscript, the reproducibility level RUNSCRIPT was 1.0, and for the other half with a different runscript, it was 0.0. This trend was the same for this same set of half of the images for RECIPE, decreasing the score (0.8) to reflect the different runscript, and for REPLICATE (0.99) to reflect the one different file. Given the building on different hosts, the IDENTICAL level was always slightly less than 1.0 (0.99). In this case, the different files between the images were those related to package manager downloads from different mirrors and those related to information about the host (e.g., /var/hosts). The level that assessed the containers as most similar was BASE (1.0 across all containers).
Local Replicates: For our equivalent collection of containers built on the same host, as expected, we saw scores of 1.0 (highest level similarity) on the all levels except for IDENTICAL, as the image files carry different timestamps. However, by way of sharing the host, we found the IDENTICAL score to be slightly higher (0.9956) than the assessment for the Singularity Hub replicates (0.9952), a result that is likely not significantly different, but expected for the levels. Complete results are included (S2 Table).
Clones: Assessment of the clone revealed scores of 1.0 across all reproducibility levels (S3 Table), an expected result as the image file is exactly the same, simply downloaded many times.
To assess if our metrics could accurately reflect a dimension of intuitive similarity scores, we calculated comparisons across levels to compare base operating systems (Alpine, Debian, Ubuntu, CentOS, and Busybox) against all versions of themselves subsequently removing one newest file until the images were empty. The scores passed our criteria of returning a value of 0.0 when no files are shared, and a value of 1.0 when the images are identical across all metrics. An example evaluation for the Busybox operating system is included in Fig 6, and additional operating systems are provided (S1–S4 Figs).
Fig 6. Reproducibility level gradients: As an assessment of metric interpretability, we calculated comparisons for each metric for a complete operating system (e.g., Busybox) against all versions of itself with one file removed until no files remained.
As we remove files starting with the newest based on time-stamp (from right to left) similarity decreases between the full container and it's comparator until we reach a score of 0.0. The metrics for RUNSCRIPT, LABELS, by way of being the newest files in the image, return a perfect score of 1.0 given that they are present in both images, which only occurs at the far right of the plot.
We calculated pairwise comparisons using the reproducibility level REPLICATE for all public images in Singularity Hub (N = 79), to generate a pairwise similarity matrix (S1 Data and https://plot.ly/vsoch/21). We found that containers clustered first on the level of operating systems, and then by common software (Fig 7). Representational similarity analysis (RSA) of the pairwise comparisons using the reproducibility level REPLICATE against pairwise comparisons done using file paths resulted in a score of of 0.74, suggesting that a comparison of file paths can capture some, but not all information done with a more rigorous comparison.
Fig 7. Hierarchical clustering of Singularity Hub public images (accessed March 28, 2017) with Ward's metric.
We observed that containers generally clustered first on the level of operating systems (dark blue) in the order of Debian, Ubuntu, and then CentOS and Busybox.
We have demonstrated that the Singularity Hub builders are reliable to produce replicates of an image, and an identical image that can be downloaded multiple times. We have also developed and provided metrics for scientists to use to compare entire containers based on a custom level of reproducibility. Each of these levels carries suggestions for intended use.
IDENTICAL: The strictest level of reproducibility comes down to the scientist providing a download of the exact container that was used for his or her work, which is a strong use case for Singularity Hub. Under these conditions, the container in Singularity Hub can be referenced in publications, linked to in web content, and available immediately on the command line via the Singularity client. Any assessment of replication of this container, given that the download is complete and successful, will return a score of 1.0 using our levels. If the scientist is interested in providing a container at this level, he or she can use the singularity-python functions to provide a hash of the file itself, which would be reliable to assess the file.
REPLICATE: If the scientist is interested in comparing containers that, although they might have been built using the same specification, were built on different hosts, or at different times, we recommend using the reproducibility level REPLICATE. A replicate will allow for different timestamps and files relevant to host information and temporary.
RECIPE: The level RECIPE and the levels that it includes (ENVIRONMENT, LABELS, and RUNSCRIPT) are useful if the scientist is only interested in assessing the intended execution (RUNSCRIPT) or environment (ENVIRONMENT) or metadata (LABELS) about the container. For example, containers with entirely different operating systems may have the same execution statement to run a scientific software. For these levels, akin to IDENTICAL, the user is able and encouraged to calculate summary hashes for later comparison because the data structure has the "assess content" field that tells the software to always use the bytes content for a specific set of files, and thus the hash generated will always reflect the content of the file and not be relevant to the time-stamp.
BASE: Using the level BASE is the best way to assess the similarity of two containers regardless of the generator's intended use. For example, two researchers might start with equivalent containers, and then have custom environment exports and runscripts to specify the container for a particular use case. While the levels IDENTICAL and REPLICATE would reflect these similar bases, they would do so less accurately than using BASE alone.
CUSTOM: The user is also encouraged to generate a custom level given that the reproducibility levels provided do not meet his or her needs.
With the singularity python-software, we hope that the user is empowered to choose the level of reproducibility that is most appropriate for his or her use case, and we provide these suggested practices to advise about when each level is most useful. For the reason that there are many use cases and no "one size fits all" solution, Singularity Hub purposefully does not bias the user to use any one level.
While an assessment of how the removal of different files, or further, groups of files is outside the scope of this paper, it is an interesting example of the kinds of work that are afforded by availability of these tools. For the first time, we can quantify the differences in a software or file footprint, whether that be a python installation, a python module, or even an extension of file. While we chose to look at files across an operating system, it is clear that this same procedure, when applied to different versions of software, or software compiled in different ways could provide detailed measurements that give insight to software optimization. For example, is equivalent software on different operating systems comparable, and by how much? Are analysis output files generated with equivalent seeds on different operating systems truly identical? Are they replicates instead? We would want to extend this kind of comparison to look at the footprint of software, and data files, and start work that might better map the network of interactions that happen within an operating system.
We were surprised at the extent of information that we were able to learn about operating systems from the plots of our reproducibility metrics. For example, across operating systems we were able to quickly determine the general proportion of symbolic links by finding constant trends in the plot (for an example, see S2 Fig for the Alpine Operating System). Since symbolic links are not accounted for in favor of the actual files, their removal does not change the score. When looking at the clustering (Fig 7) we were excited to see clear structure in even a small dataset, and hope to see future analyses with more containers across different levels.
The pairwise calculation to compare many containers is computationally not fast (2-5 seconds for a container across all levels, depending on the size). We first developed the software using lists and later increased speed by 10X by using sets. A small container of approximately 400 files can take 1.5 to 2 seconds, and a larger container of over 10K files is closer to 5 seconds. The processing time is due to the need to read bytes content directly for all files that are originally assessed to be different based on file hash. For the user wanting to make a small number of comparisons on the fly or locally, our software is reasonable to use, and for the user wanting to do many comparisons, we recommend the standard approach to scaling by way of running jobs on a cluster or in parallel, or using the singularity-python functions to cache hashes. We thought about using another heuristic that would not require reading bytes to assess the file, such as size, and while we think the comparisons would likely be accurate, they would have the potential to produce false positives (files assessed as equal based on size but are not truly equal in content).
Our current approach does not do well to identify two identical files that are named differently, whether they be located side by side in the same directory or in different locations in the image. For most software installation, we recommend to the user to ensure installation in standard system locations by way of using package managers. However, we think it would be useful to be able to "sniff" a container to assess if it contains a software of a user's choice (for example, it might be useful to know that Python anaconda version 2.0 is installed in two containers, albeit in different locations). We would consider this kind of comparison, for one file or a set, a more "functional" comparison, as using "python" in the image would have the same desired execution given that the installations are on the path. Further, we would want the user to be able to look for an entire set of files pertaining to a particular software installation, and we would want to be able to map a standard location in one operating system to a (possibly different) standard location in another. It could also be useful to alert a user when a container has more than one version of software. For example, with Python it is common to mistakenly install the same module to multiple locations, or different versions to the same installation, and then produce errors related to finding the wrong version first via the python path. We are thinking more about these problems, and currently working on functions that might help to address them.
In this same line of thought, often what is most interesting about a container isn't the software installed from package managers, but the custom software created by the scientists. Toward this goal, we hope that Singularity Hub, by way of capturing signatures of common software, can then use these signatures to identify unique software. A more robust metric would, akin to how we do with estimation of operating system, first be able to subtract out a base operating system. A more robust metric might also apply a weighting to our current algorithm to calculate the similarity score, placing higher weight on custom software.
Another limitation is a lack of normalization for software size. Currently, metrics of similarity are based on overall similarity of files, and don't account for a software packaging having more or fewer files. For example, a series of files that are not relevant for the function of the image, perhaps leftover output files, would be included in the total (in the set represented in one image but not another) and make the images look very different even if the core software (the function of the image) was equivalent. This could be addressed on a user level by creating a custom filter that would skip over the pattern of output files by regular expression, but would need to be thought about in advance. These custom sets of files are an important feature to think about, because it should be the case that groups of meaningful paths (software) can be integrated into the algorithm. To allow for the user to do these custom analyses and exploration of custom metrics, singularity-python allows the user to derive the intermediate hash values and inputs to our algorithm so he or she can develop more robust or better customized metrics.
Operating system science must focus on the assessment of not only operating systems, but software development practices, organization of systems, and changes over time. An operating system is more than a static structure of files and folders—it is a phylogenic tree where file timestamps, hashes, organization, sizes, and extensions carry rich information about what we, as humans, value in our daily lives. It could be that an older file or set of files reflects having strong structure or practices that have withstood the test of time. It could also be the case that there is a subset of these older files that are carried around but unnecessary, or perhaps executables that have great potential that have been forgotten. Comparison between file systems could show us that base operating systems are in fact very similar or different than we imagined, and might open the door to thinking about how machine learning could be used so that operating systems can define themselves, optimized for some purpose. With enough data, we might even be able to infer different types of human behavior and personality based on preferences for naming, storing, and changing our systems. The potential for this new area of research is tremendous, and we will finish this paper with some final thoughts about these developments.
The landscape of scientific software is poorly understood. It is not clear what makes good scientific software, or even what metrics we might use to quantify "good." If we are to optimize our development of scientific products, an understanding of what dependencies are commonly used, changes over time, and patterns in both development and the code itself are observed. We might also want to observe the way that operating systems are organized to properly define best practices. By preserving these metadata about scientific containers, and treating file hierarchies and extension counts as features, available with functions to our users, the developers of Singularity Hub hope to encourage work in this emerging domain. As it becomes more common practice to see research software engineers, we hope it to become common practice to quantify development procedure, code quality, and ultimate success of the product, as this is the local means to better understand where there is room for improvement.
To introspect on the future of scientific workflows and the Singularity Hub container registry, we hope to see, and have plans to develop, integrations that work with Singularity Hub. By way of making containers accessible via the Singularity command line software, Singularity containers served in the Singularity Hub registry can already be plugged into workflow software  and traditional job managers [49, 50]. We have vision for containers to provide science as a service, meaning that robust, standardized, and collaboratively developed analysis containers can be served on Singularity Hub and used by all, including those that may not have the expertise to develop the tools. Given better sharing and dissemination of these containers, we can have more specialization in the scientific process. Those with strong computational backgrounds and interest can optimally develop software, diagnose problems, and innovate methods, and those with invaluable domain knowledge and vision can focus on the asking and answering of scientific questions. While prowess in software development is a benefit for the scientist, it should not be a base requirement, and further, we would argue that each researcher independently developing custom workflows unique to an individual project and publication is inefficient.
6.5.3 Science as a service.
These components come together to support the idea of science as a service, or making it easy to plug data into analysis pipelines, run them, and return a result. We can extend this idea to describe how a more fluid and seamless pipeline, made possible by software integration with container registries, can fundamentally change the way we understand the dissemination of scientific information. Instead of the product of a researcher being a scientific result, associated with one point in time and a hard copy of a manuscript, the products of science become the workflows. If each workflow understands the kind of data inputs it can accept, it could be possible to re-run an analysis with new data inputs, produce an updated result, and thus update our understanding of the world. We may, under this kind of reality, expose an elusive concept about our reality that we have historically not been able to see: that although there may be some fundamental truths, many phenomena, tangible things, and ideas that are understood as truths can change.
We have built, deployed, and will maintain Singularity Hub as a registry for containers for scientific reproducibility. Our reproducibility level tests show that utilizing containers can enable researchers to distribute reproducible computing environments along with source code and primary data to make every aspect of computational analyses reproducible and archivable. To the best of our knowledge, our work is the first of its kind to provide means to do a comprehensive assessment of similarity between containers and operating systems. We are hopeful to incite more interest in this area to better computationally capture and define metrics for reproducible software, and develop tools and best practices for it. We encourage researchers of all computational skill-levels to consider utilizing containers to encapsulate their computing environments, and to discuss container options with IT support staff if none are currently available to them. We direct the user to the README and examples folder in the singularity-python software  to learn more, and look forward to sharing our work using this tool.
While we cannot predict if local HPC versus cloud infrastructure will be a preferable approach for researchers, the need for institution-based compute will likely endure in parallel with cloud use, and so an optimal strategy is to develop scientific products that move seamlessly between these places. Singularity containers, provided easily by the Singularity Hub registry, make this possible without needing to worry about software dependencies, or user and environment discrepancies.
S1 Fig. Reproducibility level gradient Debian.
We calculated a comparison of the Debian base operating system against all reduced versions of itself, removing files one at a time sorted by earliest first (files removed). Files removed between index 3904 and 4441 were locale relevant files in /usr/share/zoneinfo, and their removal did not change the score because they were symbolic links that are accounted for by way of comparison of the files they link to.
S2 Fig. We calculated a comparison of the Alpine base operating system against all reduced versions of itself, removing files one at a time sorted by earliest first (files removed).
The Alpine operating system is interesting in that it consists primarily of symbolic links, so that after the Singularity metadata files are removed from the comparison (right side of plot) along with other shared files, the score remains constant as the symbolic links are removed. This is a good example for how the metrics can give insight to operating systems, as we did not know this about Alpine before doing the assessment.
S3 Fig. Reproducibility level gradient Ubuntu.
We calculated a comparison of the Ubuntu base operating system against all reduced versions of itself.
S4 Fig. Reproducibility level gradient CentOS.
We calculated a comparison of the CentOS base operating system against all reduced versions of itself.
S1 Table. Singularity hub replicates.
Comparison results across reproducibility levels for a randomly selected container from the vsoch/singularity-hello-world collection against all other containers in the collection.
Comparison scores for containers built on the same host with expected scores of 1.0 (highest level similarity) for all levels except for IDENTICAL (the image files carry different timestamps).
S3 Table. Singularity hub clones.
Assessment of the clone revealed scores of 1.0 across all reproducibility levels, an expected result as the image file is exactly the same.
S1 Data. Singularity hub similarity matrix.
Pairwise similarity matrix for comparisons using the reproducibility level REPLICATE for all public images in Singularity Hub (N = 79) at the time of the analysis.
The authors would like to thank Ruth Marinshaw for her review of the manuscript, and the entire community behind the development of Singularity for making our work useful and fun.
1. Baker M. Over half of psychology studies fail reproducibility test. Nature News;.
3. Science is in a reproducibility crisis: How do we resolve it?;. http://phys.org/news/2013-09-science-crisis.html.
4. Docker-based solutions to reproducibility in science—Seven Bridges; 2015. https://blog.sbgenomics.com/docker-based-solutions-to-reproducibility-in-science/.
6. Santana-Perez I, Pérez-Hernández MS. Towards Reproducibility in Scientific Workflows: An Infrastructure-Based Approach. Sci Program. 2015;2015.
7. Broad Institute GATK on Google Genomics | Genomics | Google Cloud Platform;. https://cloud.google.com/genomics/v1alpha2/gatk.
8. Leading Genome Research Center Catalyzes Technology Partnership Between DNAnexus and Microsoft to Support Data Management and Genomic Analysis | Business Wire; 2016. http://www.businesswire.com/news/home/20161115005482/en/Leading-Genome-Research-Center-Catalyzes-Technology-Partnership.
10. Gorgolewski KJ, Alfaro-Almagro F, Auer T, Bellec P, Capota M, Chakravarty M, et al. BIDS Apps: Improving ease of use, accessibility and reproducibility of neuroimaging data analysis methods; 2016.
11. Ali AA, El-Kalioby M, Abouelhoda M. The Case for Docker in Multicloud Enabled Bioinformatics Applications. Conference on Bioinformatics and …. 2016; p. 587–601.
13. mjenkinson. NIfTI-1 Data Format — Neuroimaging Informatics Technology Initiative; 2005. http://nifti.nimh.nih.gov/nifti-1.
14. Merkel D. Docker: Lightweight Linux Containers for Consistent Development and Deployment. Linux J. 2014;2014(239).
15. Kurtzer GM, Sochat V, Bauer MW. Singularity: Scientific Containers for Mobility of Compute;.
16. Webhooks | GitHub Developer Guide;. https://developer.github.com/webhooks/.
17. Fielding Dissertation: CHAPTER 5: Representational State Transfer (REST);. http://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm.
18. vsoch. vsoch/singularity-python specifications for levels of container reproducibility;. https://github.com/singularityware/singularity-python.
19. Build software better, together;. https://github.com/.
20. Pushing to a remote—User Documentation;. https://help.github.com/articles/pushing-to-a-remote/.
21. Git Commits | GitHub Developer Guide;. https://developer.github.com/v3/git/commits/.
22. Integration of a database into file management software for protecting, tracking and retrieving data. 6212512; 2001.
23. Computer file management and backup system. 5664186; 1997.
24. File management system. 5047918; 1991.
26. van Rijsbergen CJ. Information Retrieval. vol. ISBN 3-642-12274-4. Butterworths, London; 1979.
27. Google Cloud Platform Auth Guide | Documentation | Google Cloud Platform;. https://cloud.google.com/docs/authentication.
28. PostgreSQL: Documentation: 9.3: Hot Standby;. https://www.postgresql.org/docs/9.3/static/hot-standby.html.
29. Welcome to NGINX Wiki's documentation! NGINX;. https://www.nginx.com/resources/wiki/.
30. The Web framework for perfectionists with deadlines | Django;. https://www.djangoproject.com/.
32. What Is The Metadata API—Overview | Analytics Metadata API | Google Developers;. https://developers.google.com/analytics/devguides/reporting/metadata/v3/.
33. diff(1)—Linux manual page;. http://man7.org/linux/man-pages/man1/diff.1.html.
34. Sochat V. Standard Container Integration Format;. http://containers-ftw.org/SCI-F/.
35. 15.7.logging—Logging facility for Python — Python 2.7.13 documentation;. https://docs.python.org/2/library/logging.html.
36. Borgman CL. The conundrum of sharing research data. J Am Soc Inf Sci Technol. 2012;63(6):1059–1078.
39. 15.1. hashlib — Secure hashes and message digests — Python 3.6.1 documentation;. https://docs.python.org/3/library/hashlib.html.
40. Rivest R. The MD5 message-digest algorithm. 1992;.
41. Sklavos N, Koufopavlou O. On the hardware implementations of the SHA-2 (256, 384, 512) hash functions. In: Circuits and Systems, 2003. ISCAS'03. Proceedings of the 2003 International Symposium on. vol. 5; 2003. p. V–153–V–156 vol.5.
42. cat(1)—Linux manual page;. http://man7.org/linux/man-pages/man1/cat.1.html.
44. Wilson R. Automated Capture of Pulmonary Embolism Spatial Location in Dictated Reports Using the ConText Algorithm;. http://archive.rsna.org/2011/11016603.html.
45. vsoch. vsoch/singularity-python build consistency assessment ipython notebook;. https://github.com/singularityware/singularity-python/blob/master/examples/shub/paper/compare_builds.ipynb.
46. vsoch. singularity-hub vsoch/singularity-hello-world;. https://singularity-hub.org/collections/17/.
48. Nextflow—A DSL for parallel and scalable computational pipelines;. https://www.nextflow.io/.
49. Slurm Workload Manager;. https://slurm.schedmd.com/plugins.html.
50. SGE Manual Pages;. http://gridscheduler.sourceforge.net/htmlman/manuals.html.
Is the Subject Area "Operating systems" applicable to this article?
Is the Subject Area "Reproducibility" applicable to this article?
Is the Subject Area "Scientists" applicable to this article?
Is the Subject Area "Software development" applicable to this article?
Is the Subject Area "Software tools" applicable to this article?
Is the Subject Area "Web-based applications" applicable to this article?
Is the Subject Area "Computer software" applicable to this article?