Dolphins are one of the smartest animals on the planet. They can be aggressive as well, but if they know a reward is waiting later they’ll happily join us silly humans in a game of […]
The post Dolphin Encounter appeared first on Viral Viral Videos.
While I don’t want to say everyone needs to have a minivan, as it is super handy, I think everyone needs to have a minivan. As it is super handy. Look at the possibilities here! […]
The post Minivan Snowplow Now Has Wings appeared first on Viral Viral Videos.
Starting with Java, a robust built-in class library is practically a default feature of modern programming languages. Why struggle with OS-specific behaviors, or with writing your own code, or managing a third party library to handle problems like accessing files or network resources.
One common class of WTF is the developer who steadfastly refuses to use it. They inevitably reinvent the wheel as a triangle with no axle. Another is the developer who is simply ignorant of what the language offers, and is too lazy to Google it. They don’t know what a wheel is, so they invent a coffee-table instead.
My personal favorite, though, is the rare person who knows about the class library, that uses the class library… to reinvent methods which exist in the class library. They’ve seen a wheel, they know what a wheel is for, and they still insist on inventing a coffee-table.
The method in question is called thus:
if output_exists("/some/path.dat"):
do_something()
I want to stress, this is the only use of this method. The purpose is to check if a file containing output from a different process exists. If you’re familiar with Python, you might be thinking, “Wait, isn’t that just os.path.exists?”
Of course not.
def output_exists(full_path):
path = os.path.dirname(full_path) + "/*"
filename2=full_path.split('/')[-1]
filename = '%s' % filename2
files = glob.glob(path)
back = []
for f in re.findall(filename, " ".join(files)):
back.append(os.path.join(os.path.dirname(full_path), f))
return back
Now, in general, most of your directory-tree manipulating functions live in the os.path package, and you can see os.path.dirname used. That splits off the directory-only part. Then they throw a glob on it. I could, at this point, bring up the importance of os.path.join for that sort of operation, but why bother?
They knew enough to use os.path.dirname to get the directory portion of the path, but not os.path.split which can pick off the file portion of the path. The “Pythonic” way of writing that line would be (path, filename) = os.path.split(full_path). Wait, I misspoke: the “Pythonic” way would be to not write any part of this method.
'%s' % filename2 is how Python’s version of printf and I cannot for the life of me guess why it’s being done here. A misguided attempt at doing an strcpy-type operation?
glob.glob isn’t just the best method name in anything, it also does a filesystem search using globs, so files contains a list of all files in that directory.
" ".join(files) is the Python idiom for joining an array, so we turn the list of files into an array and search it using re.findall… which uses a regex for searching. Note that they’re using the filename for the regex, and they haven’t placed any guards around it, so if the input file is “foo.c”, and the directory contains “foo.cpp”, this will think that’s fine.
And then last but not least, it returns the array of matches, relying on the fact that an empty array in Python is false.
To write this code required at least some familiarity with three different major packages in the class library- os.path, glob, and re, but just one ounce of more familiarity ith os.path would have replaced the entire thing with a simple call to os.path.exists. Which is what Anneke did.
[Advertisement] High availability, Load-balanced or Basic – design your own Universal Package Manager, allow the enterprise to scale as you grow. Download and see for yourself!
A cat always lands safely, is what they say. This cat was ready to take the ultimate test, and board the flight of a lifetime. Wait until the people discover him and watch the thrilling […]
The post Remove Cat Before Flight appeared first on Viral Viral Videos.
Cats and birds, normally a toxic and fatal combination. Arch-enemies until the bitter end. But not these guys. The cats have mercy on this crow, and they eat together like one big, happy family. Aww!
The post Cats Adopt A Crow appeared first on Viral Viral Videos.
“Hydranix” can’t provide much detail about today’s code, because they’re under a “strict NDA”. All they could tell us was that it’s C++, and it’s part of a “mission critical” front end package. Honestly, I think this line speaks for itself:
(mil == 999 ? (!(mil = 0) && (sec == 59 ?
(!(sec = 0) && (min == 59 ?
(!(min = 0) && (++hou)) : ++min)) : ++sec)) : ++mil);
“Hydranix” suspects that this powers some sort of stopwatch, but they’re not really certain what it’s role is.
[Advertisement] Manage IT infrastructure as code across all environments with Puppet. Puppet Enterprise now offers more control and insight, with role-based access control, activity logging and all-new Puppet Apps. Start your free trial today!
Trick shots belong on the basketball court or in a videogame, not on the parking lot or in the kitchen, right? Right?! Some people just want to watch the world burn. They throw their trick […]
The post Real Life Trick Shots appeared first on Viral Viral Videos.
Pigs are often associated with mud and dirtiness. But did you know they are actually one of the smartest animals alive? Look at this fine example, cleaning up its room to keep a clear mind. […]
The post Pigs Are Smarter Than You Think appeared first on Viral Viral Videos.
PT didn’t provide very much information about today’s Representative Line.
Clearly bits and bytes was not something studied in this SQL stored procedure author. Additionally, Source control versions are managed with comments. OVER 90 Thousand!
--Declare @PrevNumber smallint
--2015/11/18 - SMALLINT causes overflow error when it goes over 32000 something
-- - this sp errors but can only see that when
-- code is run in SQL Query analyzer
-- - we should also check if it goes higher than 99999
DECLARE @PrevNumber int --2015/11/18
Fortunately, I am Remy Poirot, the world’s greatest code detective. To your untrained eyes, you simply see the kind of comment which would annoy you. But I, an expert, with experience of the worst sorts of code man may imagine, can piece together the entire lineage of this code.
Let us begin with the facts: no source control is in use. Version history is managed in the comments. From this, we can deduce a number of things: the database where this code runs is also where it is stored. Changes are almost certainly made directly in production.
Which, when those changes fail, they may only be detected when the “code is run in SQL Query Analyzer”. This ties in with the “changes in production/no source control”, but it also tells us that it is possible to run this code, have it fail, and no one notices. This means this code must be part of an unattended process, a batch job of some kind. Even an overflow error vanishes into the ether.
This code also, according to the comments, should “also check if [@PrevNumber] goes higher than 99999”. This is our most vital clue, for it tells us that the content of the value has a maximum width- more than 5 characters to represent it is a problem. This obviously means that the target system is a mainframe with a flat-file storage model.
Already, from one line and a handful of comments, we’ve learned a great deal about this code, but one need not be the world’s greatest code detective to figure out this much. Let’s see what else we can tease out.
@PrevNumber must tie to some ID in the database, likely the “last processed ID” from the previous run of the batch job. The confusion over smallint and need to enforce a five-digit limit implies that this database isn’t actually in control of its data. Either the data comes from a front-end with no validation- certainly possible- or it comes from an external system. But a value greater than 99999 isn’t invalid in the database- otherwise they could enforce that restriction via a constraint. This means the database holds data coming from and going to different places- it’s a “business integration” database.
With these clues, we can assemble the final picture of the crime scene.
In a dark corner of a datacenter are the components of a mainframe system. The original install was likely in the 70s, and while it saw updates and maintenance for the next twenty years, starting in the 90s it was put on life support. “It’s going away, any day now…” Unfortunately, huge swathes of the business depended on it and no one is entirely certain what it does. They can’t simply port business processes to a new system, because no one knows what the business processes are. They’re encoded as millions of lines of code in a dialect of COBOL no one understands.
A conga-line of managers have passed through the organization, trying to kill the mainframe. Over time, they’ve brought in ERP systems from Oracle or SAP. Maybe they’ve taken some home-grown ERP written by users in Access and tried to extend them to an enterprise solution. Worse, over the years, acquisitions come along, bringing new systems from other vendors under the umbrella of one corporate IT group.
All these silos need to talk to each other. They also have to be integrated into the suite of home-grown reporting tools, automation, and Excel spreadsheets that run the business. Shipping can only pull from the mainframe, while the P/L dashboard the executives use can only pull from SAP. At first, it’s a zoo of ETL jobs, until someone gets the bright idea to centralize it.
They launch a project, and give it a slick three-letter-acronym, like “QPR” or “LMP”. Or, since there are only so many TLAs one can invent, they probably reuse an existing one, like “GPS” or “FBI”. The goal: have a central datastore that integrates data from every silo in the organization, and then the silos can pull back out the data they want for their processes. This project has a multi-million dollar budget, and has exceeded that budget twice over, and is not yet finished.
The code PT supplied for us is but one slice of that architecture. It’s pulling data from one of those centralized tables in the business integration database, and massaging it into a format it can pass off to the mainframe. Like a murder reconstructed from just a bit of fingernail, we’ve laid bare the entire crime with our powers of observation, our experience, and our knowledge of bad code.
[Advertisement] Release! is a light card game about software and the people who make it. Play with 2-5 people, or up to 10 with two copies - only $9.95 shipped!
Eating out is usually associated with dining decadently in a spacious, tasteful establishment. Well, this place has all those things covered, except for the spacious part. It’s one of the tiniest restaurants you’ll ever see, […]
The post This Is One Of The Smallest Restaurants In New York appeared first on Viral Viral Videos.
When you’re watching a movie, you usually don’t see the blood, sweat and tears that go into every stunt. You only see the end-result, unless the dvd comes with a blooper-reel. This is your chance […]
The post Hollywood Stunt Falls in Slow Motion appeared first on Viral Viral Videos.
The best way to show you’re the ultimate Disney fan you ask? Well, look no further. How about arranging the most important event of your life, your wedding, in the Disney theme of your choice? […]
The post 10 Epic Weddings Inspired By Disney Movies appeared first on Viral Viral Videos.
What do you usually do when your best friend is asleep and you want to play? This dog’s best friend is a heavy sleeper, and not easy to wake up. But persistence can get you […]
The post Dog Tries To Wake Up Sleeping Pig appeared first on Viral Viral Videos.
Joe P. wrote, When I tried to buy a coffee at the airport with my contactless VISA card, it apparently thought my name was '%s'."
"Instead of outsourcing to Eastern Europe or the Asian subcontinent, companies should be hiring from Malta. Just look at these people! They speak fluent base64!" writes Michael J.
Raffael wrote, "While I can proudly say that I am working on bugs, the Salesforce Chatter site should probably consider doing the same."
"Wow! Thanks! Happy Null Year to you too!" Alexander K. writes.
Joel B. wrote, "Yesterday was the first time I've ever seen a phone with a 'License Violation'. Phone still works, so I guess there's that."
"They missed me so much, they decided to give me...nothing," writes Timothy.
[Advertisement] Release! is a light card game about software and the people who make it. Play with 2-5 people, or up to 10 with two copies - only $9.95 shipped!
Technology improves over time. Storage capacity increases. Spinning platters are replaced with memory chips. CPUs and memory get faster. Moore's Law. Compilers and languages get better. More language features become available. But do these changes actually improve things? Fifty years ago, meteorologists used the best mainframes of the time, and got the weather wrong more than they got it right. Today, they have a global network of satellites and supercomputers, yet they're wrong more than they're right (we just had a snowstorm in NJ that was forecast as 2-4", but got 16" before drifting).
As with most other languages, FORTRAN also added structure, better flow control and so forth. The problem with languages undergoing such a massive improvement is that occasionally, coding styles live for a very long time.
Imagine a programmer who learned to code using FORTRAN IV (variable names up to 6 characters, integers implicitly start with "I" through "N" and reals start with any other letter - unless explicitly declared, flow control via GOTO, etc) writing a program in 2000 (using a then-current compiler but with FORTRAN IV style). Now imagine some PhD candidate coming along in 2017 to maintain and enhance this FORTRAN IV-style code with the latest FORTRAN compiler.
A.B.was working at a university with just such a scientific software project as part of earning a PhD. These are just a couple of the things that caused a few head-desk moments.
Include statements. The first variant only allows code to be included. The second allows preprocessor directives (like #define).
INCLUDE 'path/file'
#include 'path/file'
Variables. Since the only data types/structures originally available were character, logical, integer, real*4, real*8 and arrays, you had to shoehorn your data into the closest fit. This led to declarations sections that included hundreds of basic declarations. This hasn't improved today as people still use one data type to hold something that really should be implemented as something else. Also, while the compilers of today support encapsulation/modules, back then, everything was pretty much global.
Data structures. The only thing supported back then was multidimensional arrays. If you needed something like a map, you needed to roll your own. This looks odd to someone who cut their teeth on a version of the language where these features are built-in.
Inlining. FORTRAN subroutines support local subroutines and functions which are inlined, which is useful to provide implied visibility scoping. Prudent use allows you to DRY your code. This feature isn't even used, so the same code is duplicated over and over again inline. Any of you folks see that pattern in your new-fangled modern systems?
Joel Spolsky commented about the value of keeping old code around. While there is much truth in his words, the main problem is that the original programmers invariably move on, and as he points out, it is much harder to read (someone else's) code than to write your own; maintenance of ancient code is a real world issue. When code lives across too many language version improvements, it becomes inherently more difficult to maintain as its original form becomes more obsolete.
To give you an idea, take a look at the just the declaration section of one module that A.B. inherited (except for a 2 line comment at the top of the file, there were no comments). FWIW, when I did FORTRAN at the start of my career, I used to document the meaning of every. single. abbreviated. variable. name.
subroutine thesub(xfac,casign,
& update,xret,typret,
& meop1,meop2,meop12,meoptp,
& traop1, traop2, tra12,
& iblk1,iblk2,iblk12,iblktp,
& idoff1,idoff2,idof12,
& cntinf,reoinf,
& strinf,mapinf,orbinf)
implicit none
include 'routes.h'
include 'contr_times.h'
include 'opdim.h'
include 'stdunit.h'
include 'ioparam.h'
include 'multd2h.h'
include 'def_operator.h'
include 'def_me_list.h'
include 'def_orbinf.h'
include 'def_graph.h'
include 'def_strinf.h'
include 'def_filinf.h'
include 'def_strmapinf.h'
include 'def_reorder_info.h'
include 'def_contraction_info.h'
include 'ifc_memman.h'
include 'ifc_operators.h'
include 'hpvxseq.h'
integer, parameter ::
& ntest = 000
logical, intent(in) ::
& update
real(8), intent(in) ::
& xfac, casign
real(8), intent(inout), target ::
& xret(1)
type(coninf), target ::
& cntinf
integer, intent(in) ::
& typret,
& iblk1, iblk2, iblk12, iblktp,
& idoff1,idoff2,idof12
logical, intent(in) ::
& traop1, traop2, tra12
type(me_list), intent(in) ::
& meop1, meop2, meop12, meoptp
type(strinf), intent(in) ::
& strinf
type(mapinf), intent(inout) ::
& mapinf
type(orbinf), intent(in) ::
& orbinf
type(reoinf), intent(in), target ::
& reoinf
logical ::
& bufop1, bufop2, buf12,
& first1, first2, first3, first4, first5,
& msfix1, msfix2, msfx12, msfxtp,
& reject, fixsc1, fixsc2, fxsc12,
& reo12, non1, useher,
& traop1, traop2
integer ::
& mstop1,mstop2,mst12,
& igmtp1,igmtp2,igmt12,
& nc_op1, na_op1, nc_op2, na_op2,
& nc_ex1, na_ex1, nc_ex2, na_ex2,
& ncop12, naop12,
& nc12tp, na12tp,
& nc_cnt, na_cnt, idxres,
& nsym, isym, ifree, lenscr, lenblk, lenbuf,
& buftp1, buftp1, bftp12,
& idxst1, idxst2, idxt12,
& ioff1, ioff2, ioff12,
& idxop1, idxop2, idop12,
& lenop1, lenop2, len12,
& idxm12, ig12ls,
& mscmxa, mscmxc, msc_ac, msc_a, msc_c,
& msex1a, msex1c, msex2a, msex2c,
& igmcac, igamca, igamcc,
& igx1a, igx1c, igx2a, igx2c,
& idxms, idxdis, lenmap, lbuf12, lb12tp,
& idxd12, idx, ii, maxidx
integer ::
& ncblk1, nablk1, ncbka1, ncbkx1,
& ncblk2, nablk2, ncbka2, ncbkx2,
& ncbk12, nabk12, ncb12t, nab12t,
& ncblkc, nablkc,
& ncbk12, nabk12,
& ncro12, naro12,
& iblkof
type(filinf), pointer ::
& ffop1,ffop2,ff12
type(operator), pointer ::
& op1, op2, op1op2, op12tp
integer, pointer ::
& cinf1c(:,:),cinf1a(:,:),
& cinf2c(:,:),cinf2a(:,:),
& cif12c(:,:),
& cif12a(:,:),
& cf12tc(:,:),
& cf12ta(:,:),
& cfx1c(:,:),cfx1a(:,:),
& cfx2c(:,:),cfx2a(:,:),
& cfcntc(:,:),cfcnta(:,:),
& inf1c(:),
& inf1a(:),
& inf2c(:),
& inf2a(:),
& inf12c(:),
& inf12a(:),
& dmap1c(:),dmap1a(:),
& dmap2c(:),dmap2a(:),
& dm12tc(:),dm12ta(:)
real(8) ::
& xnrm, facscl, fcscl0, facab, xretls
real(8) ::
& cpu, sys, cpu0, sys0, cpu00, sys00
real(8), pointer ::
& xop1(:), xop2(:), xop12(:), xscr(:)
real(8), pointer ::
& xbf1(:), xbf2(:), xbf12(:), xbf12(:), x12blk(:)
integer ::
& msbnd(2,3), igabnd(2,3),
& ms12ia(3), ms12ic(3), ig12ia(3), ig12ic(3),
& ig12rw(3)
integer, pointer ::
& gm1dc(:), gm1da(:),
& gm2dc(:), gm2da(:),
& gmx1dc(:), gmx1da(:),
& gmx2dc(:), gmx2da(:),
& gmcdsc (:), gmcdsa (:),
& gmidsc (:), gmidsa (:),
& ms1dsc(:), ms1dsa(:),
& ms2dsc(:), ms2dsa(:),
& msx1dc(:), msx1da(:),
& msx2dc(:), msx2da(:),
& mscdsc (:), mscdsa (:),
& msidsc (:), msidsa (:),
& idm1ds(:), idxm1a(:),
& idm2ds(:), idxm2a(:),
& idx1ds(:), ixms1a(:),
& idx2ds(:), ixms2d(:),
& idxdc (:), idxdsa (:),
& idxmdc (:),idxmda (:),
& lstrx1(:),lstrx2(:),lstcnt(:),
& lstr1(:), lstr2(:), lst12t(:)
integer, pointer ::
& mex12a(:), m12c(:),
& mex1ca(:), mx1cc(:),
& mex2ca(:), mx2cc(:)
integer, pointer ::
& ndis1(:,:), dgms1(:,:,:), gms1(:,:),
& lngms1(:,:),
& ndis2(:,:), dgms2(:,:,:), gms2(:,:),
& lngms2(:,:),
& nds12t(:,:), dgms12(:,:,:),
& gms12(:,:),
& lgms12(:,:),
& lg12tp(:,:), lm12tp(:,:,:)
integer, pointer ::
& cir12c(:,:), cir12a(:,:),
& ci12c(:,:), ci12a(:,:),
& mire1c(:), mire1a(:),
& mire2c(:), mire2a(:),
& mca12(:), didx12(:), dca12(:),
& mca1(:), didx1(:), dca1(:),
& mca2(:), didx2(:), dca2(:),
& lenstr_array(:,:,:)
c dbg
integer, pointer ::
& dum1c(:), dum1a(:), hpvx1c(:), hpvx1a(:),
& dum2c(:), dum2a(:), hpvx2c(:), hpvx2a(:)
integer ::
& msd1(ngastp,2,meop1%op%njoined),
& msd2(ngastp,2,meop2%op%njoined),
& jdx, totc, tota
c dbg
type(graph), pointer ::
& graphs(:)
integer, external ::
& ielsum, ielprd, imdst2, glnmp, idxlst,
& mxdsbk, m2ims4
logical, external ::
& nxtdis, nxtds2, lstcmp,
& nndibk, nndids
real(8), external ::
& ddot
[Advertisement] Universal Package Manager - ProGet easily integrates with your favorite Continuous Integration and Build Tools, acting as the central hub to all your essential components. Learn more today!
Oh, PHP. It's the butt of any number of jokes in the programming community. Those who do PHP often lie and pretend they don't, just to avoid the social stigma. Today's submitter not only works in PHP, but they also freelance: the bottom of the bottom of the development hierarchy.
Last year, Ilya was working on a Joomla upgrade as well as adjusting several components on a big, obscure website. As he was poking around in the custom code, he found today's submission. You see, the website is in Italian. At the top of the page, it shows not only the date, but also the saint of the day. This is a Catholic thing: every day of the year has a patron saint, and in certain cultures, you might even be named for the saint whose day you were born on. A full list can be found on this Italian Wikipedia page.
Every day, the website was supposed to display text like "18 luglio: santi Sinforosa e sette compagni" (July 18: Sinforosa and the Seven Companions). But the code that generated this string had broken. It wasn't Ilya's task to fix it, but he chose to do so anyway, because why not?
His first suspect for where this text came from was this mess of Javascript embedded in the head:
function getDataGiorno(){
data = new Date();
ora =data.getHours();
minuti=data.getMinutes();
secondi=data.getSeconds();
giorno = data.getDay();
mese = data.getMonth();
date= data.getDate();
year= data.getYear();
if(minuti< 10)minuti="0"+minuti;
if(secondi< 10)secondi="0"+secondi;
if(year<1900)year=year+1900;
if(ora<10)ora="0"+ora;
if(giorno == 0) giorno = " Domenica ";
if(giorno == 1) giorno = " Lunedì ";
if(giorno == 2) giorno = " Martedì ";
if(giorno == 3) giorno = " Mercoledì ";
if(giorno == 4) giorno = " Giovedì ";
if(giorno == 5) giorno = " Venerdì ";
if(giorno == 6) giorno = " Sabato ";
if(mese == 0) mese = "gennaio ";
if(mese ==1) mese = "febbraio ";
if(mese ==2) mese = "marzo ";
if(mese ==3) mese = "aprile ";
if(mese ==4) mese = "maggio ";
if(mese ==5) mese = "giugno ";
if(mese ==6) mese = "luglio ";
if(mese ==7) mese = "agosto ";
if(mese ==8) mese = "settembre ";
if(mese ==9) mese = "ottobre ";
if(mese ==10) mese = "novembre ";
if(mese ==11) mese = "dicembre";
var dt=date+" "+mese+" "+year;
var gm =date+"_"+mese;
return gm.replace(/^\s+|\s+$/g,""); ;
}
function getXMLHttp() {
var xmlhttp = null;
if (window.ActiveXObject) {
if (navigator.userAgent.toLowerCase().indexOf("msie 5") != -1) {
xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
} else {
xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");
}
}
if (!xmlhttp && typeof(XMLHttpRequest) != 'undefined') {
xmlhttp = new XMLHttpRequest()
}
return xmlhttp
}
function elaboraRisposta() {
var dt=getDataGiorno();
var data = dt.replace('_',' ');
if (dt.indexOf('1_')==0){
dt.replace('1_','%C2%BA');
}
// alert("*"+dt+"*");
var temp = new Array();
temp = objHTTP.responseText.split(dt);
//alert(temp[1]);
var temp1=new Array();
temp1=temp[1].split(":");
temp=temp1[1].split("");
if (objHTTP.readyState == 4) {
santi=temp[0].split(",");
//var app = new Array();
//app=santi[0].split(";");
santo=santi[0];
//alert(santo);
// document.write(data+" - "+santo.replace(/\/wiki\//g,"http://it.wikipedia.org/wiki/"));
document.write(data+" - "+santo);
}else {
}
}
function loadDati() {
objHTTP = getXMLHttp();
objHTTP.open("GET", "calendario.html" , false);
objHTTP.onreadystatechange = function() {elaboraRisposta()}
objHTTP.send(null)
}
If you've never seen Joomla before, do note that most templates use jQuery. There's no need to use ActiveXObject here.
"calendario.html" contained very familiar text: a saved copy of the Wikipedia page linked above. This ought to be splitting the text with the date, avoiding parsing HTML with regex by using String.prototype.split(), and then parsing the HTML to get the saint for that date to inject into the HTML.
But what if a new saint gets canonized, and the calendar changes? By caching a local copy, you ensure that the calendar will get out of date unless meticulously maintained. Therefore, the code to call this Javascript was commented out entirely in the including page:
<div class="santoForm">
<!-- <?php echo "<script>loadDati()</script>" ; ?> -->
<?php ...
Instead, it had been replaced with this:
setlocale(LC_TIME, 'ita', 'it_IT.utf8');
$gg = ltrim(strftime("%d"), '0');
if ($gg=='1'){
$dt=ltrim(strftime("1º %B"), '0');
}else{
$dt=ltrim(strftime("%d %B"), '0');
}
//$dt='4 febbraio';
$html = file_get_contents('http://it.wikipedia.org/wiki/Calendario_dei_santi');
$doc = new DOMDocument();
$doc->loadHTML($html);
$elements = $doc->getElementsByTagName('li');
foreach ($elements as $element) {
if (strpos($element->nodeValue,utf8_encode($dt))!== false){
list($santo,$after)= split(';',$element->nodeValue);
break ;
}else {}
}
list($santo,$after)= split(',',utf8_decode($santo));
if (strlen ( $santo) > 55) {
$santo=substr($santo, 0, 55)."...";
}
This migrates the logic to the backend—the One True Place for all such logic—and uses standard library routines, just as it should. Of course, this being PHP, it breaks horribly if you look at it cross-eyed, or—like Ilya—don't have the Italian locale installed on your development machine. And of course, it'll also break if the live Wikipedia page about the saints gets reformatted. But what's the likelihood of that? Plus, it's not cached in the least, letting every visitor see updates in real time. After all, next time they canonize a saint, everyone will rush right to this site to verify that the day changed. That's how the Internet works, right?
[Advertisement] Application Release Automation for DevOps – integrating with best of breed development tools. Free for teams with up to 5 users. Download and learn more today!
Michael W came into the office to a hair-on-fire freakout: the midnight jobs failed. The entire company ran on batch processes to integrate data across a dozen ERPs, mainframes, CRMs, PDQs, OMGWTFBBQs, etc.: each business unit ran its own choice of enterprise software, but then needed to share data. If they couldn’t share data, business ground to a halt.
Business had ground to a halt, and it was because the archiver job had failed to copy some files. Michael owned the archiver program, not by choice, but because he got the short end of that particular stick.
The original developer liked logging. Pretty much every method looked something like this:
public int execute(Map arg0, PrintWriter arg1) throws Exception {
Logger=new Logger(Properties.getString("LOGGER_NAME"));
Log=new Logger(arg1);
.
.
.
catch (Exception e) {
e.printStackTrace();
Logger.error("Monitor: Incorrect arguments");
Log.printError("Monitor: Incorrect arguments");
arg1.write("In Correct Argument Passed to Method.Please Check the Arguments passed \n \r");
System.out.println("Monitor: Incorrect arguments");
}
Sometimes, to make the logging even more thorough, the catch block might look more like this:
catch(Exception e){
e.printStackTrace();
Logger.error("An exception happened during SFTP movement/import. " + (String)e.getMessage());
}
Java added Generics in 2004. This code was written in 2014. Does it use generics? Of course not. Every Hashtable is stringly-typed:
Hashtable attributes;
.
.
.
if (((String) attributes.get(key)).compareTo("1") == 0 | ((String) attributes.get(key)).compareTo("0") == 0) { … }
And since everything is stringly-typed, you have to worry about case-sensitive comparisons, but don’t worry, the previous developer makes sure everything’s case-insensitive, even when comparing numbers:
if (flag.equalsIgnoreCase("1") ) { … }
And don’t forget to handle Booleans…
public boolean convertToBoolean(String data) {
if (data.compareToIgnoreCase("1") == 0)
return true;
else
return false;
}
And empty strings…
if(!TO.equalsIgnoreCase("") && TO !=null) { … }
Actually, since types are so confusing, let’s make sure we’re casting to know-safe types.
catch (Exception e) {
Logger.error((Object)this, e.getStackTraceAsString(), null, null);
}
Yes, they really are casting this to Object.
Since everything is stringly typed, we need this code, which checks to see if a String parameter is really sure that it’s a string…
protected void moveFile(String strSourceFolder, Object strSourceObject,
String strDestFolder) {
if (strSourceObject.getClass().getName().compareToIgnoreCase("java.lang.String") == 0) { … }
…
}
Now, that all was enough to get Michael’s blood pressure up, but none of that had anything to do with his actual problem. Why did the copy fail? The logs were useless, as they were spammed with messages with no particular organization. The code was bad, sure, so it wasn’t surprising that it crashed. For a little while, Michael thought it might be the getFiles method, which was supposed to identify which files needed to be copied. It did a recursive directory search (with no depth checking, so one symlink could send it into an infinite loop) nor did it actually filter files that it didn’t care about. It just made an ArrayList of every file in the directory structure and then decided which ones to copy.
He spent some time really investigating the copy method, to see if that would help him understand what went wrong:
sourceFileLength = sourceFile.length();
newPath = sourceFile.getCanonicalPath();
newPath = newPath.replace(".lock", "");
newFile = new File(newPath);
sourceFile.renameTo(newFile);
destFileLength = newFile.length();
while(sourceFileLength!=destFileLength)
{
//Copy In Progress
}
//Remy: I didn't elide any code from the inside of that while loop- that is exactly how it's written, as an empty loop.
Hey, out of curiosity, what does the JavaDoc have to say about renameTo?
Many aspects of the behavior of this method are inherently platform-dependent: The rename operation might not be able to move a file from one filesystem to another, it might not be atomic, and it might not succeed if a file with the destination abstract pathname already exists. The return value should always be checked to make sure that the rename operation was successful.
It only throws exceptions if you don’t supply a destination, or if you don’t have permissions to the files. Otherwise, it just returns false on a failure.
So… if the renameTo operation fails, the archiver program will drop into an infinite loop. Unlogged. Undetected. That might seem like the root cause of the failure, but it wasn’t.
As it turned out, the root cause was that someone in ops hit “Ok” on a security update, which triggered a reboot, disrupting all the scheduled jobs.
Michael still wanted to fix the archiver program, but there was another problem with that. He owned the InventoryArchiver.jar. There was also OrdersArchiver.jar, and HRArchiver.jar, and so on. They had all been “written” by the same developer. They all did basically the same job. So they were all mostly copy-and-paste jobs with different hard-coded strings to specify where they ran. But they weren’t exactly copy-and-paste jobs, so each one had to be analyzed, line by line, to see where the logic differences might possibly crop up.
[Advertisement] Infrastructure as Code built from the start with first-class Windows functionality and an intuitive, visual user interface. Download Otter today!
“Probably the best thing to do is try and reorganize the project some,” Tim, “Alien”’s new boss said. “It’s a bit of a mess, so a little refactoring will help you understand how the code all fits together.”
“Alien” grabbed the code from git, and started walking through the code. As promised, it was a bit of a mess, but partially that mess came from their business needs. There was a bunch of common functionality in a Common module, but for each region they did business in- Asia, North America, Europe, etc.- there was a region specific deployable, each in its own module. Each region had its own build target that would include the Common module as part of the build process.
The region-specific modules were vaguely organized into sub-modules, and that’s where “Alien” settled in to start reorganizing. Since Asia was the largest, most complicated module, they started there, on a sub-module called InventoryManagement. THey moved some files around, set up the module and sub-modules in Maven, and then rebuilt.
The Common library failed to build. This gave “Alien” some pause, as they hadn’t touched anything pertaining to the Common project. Specifically, Common failed to build because it was looking for some files in the Asia.InventoryManagement sub-module. Cue the dive into the error trace and the vagaries of the build process. Was there a dependency between Common and Asia that had gone unnoticed? No. Was there a build-order issue? No. Was Maven just being… well, Maven? Yes, but that wasn’t the problem.
After hunting around through all the obvious places, “Alien” eventually ran an ls -al.
~/messy-app/base/Common/src/com/mycompany > ls -al
lrwxrwxrwx 1 alien alien 39 Jan 4 19:10 InventoryManagement -> ../../../../../Asia/InventoryManagement/src/com/mycompany/IM/
drwxr-x--- 3 alien alien 4096 Jan 4 19:10 core/
Yes, that is a symbolic link. A long-ago predecessor discovered that the Asia.InventoryManagement sub-module contained some code that was useful across all modules. Acutally moving that code into Common would have involved refactoring Asia, which was the largest, most complicated module. Presumably, that sounded like work, so instead they just added a sym-link. The files actually lived in Asia, but were compiled into Common.
“Alien” writes, “This is the first time in my over–20-year working life I see people reuse source code like this.”
They fixed this, and then went hunting, only to find a dozen more examples of this kind of code “reuse”.
[Advertisement] Release! is a light card game about software and the people who make it. Play with 2-5 people, or up to 10 with two copies - only $9.95 shipped!
I don’t care, just give me some attentions! Just one attentions, or maybe two! That’s all I ask for you silly human! Pet me!
The post Sit Still I’m Trying To Read! appeared first on Viral Viral Videos.
Living life out of a suitcase isn’t always as great as it seems. You see more hotels than you see your own backyard. When you’re a dog I imagine it’s even worse, not being able […]
The post Bella And Pippa appeared first on Viral Viral Videos.
"I appreciate that TIAA doesn't want to fully recognize that the country once known as Burma now calls itself Myanmar, but I don't think that this is the way to handle it," Bruce R. writes.
"MSI Installed an update - but I wonder what else it decided to update in the process? The status bar just kept going and going..." writes Jon T.
Paul J. wrote, "Apparently my occupation could be 'All Other Persons' on this credit card application!"
Geoff wrote, "So I need to commit the changes I didn't make, and my options are 'don't commit' or 'don't commit'?"
David writes, "This was after a 15 minute period where I watched a timer spin frantically."
"It's as if DealeXtreme says 'three stars, I think you meant to say FIVE stars'," writes Henry N.
[Advertisement] Universal Package Manager – store all your Maven, NuGet, Chocolatey, npm, Bower, TFS, TeamCity, Jenkins packages in one central location. Learn more today!
I had to read the title twice to prepare myself for what I was about to see, but in the end, it’s pretty funny.
The post My Parrot Laughs When I Blow On Him appeared first on Viral Viral Videos.
Does it ever get cuter than this? Despite the cold and the wet hooves, this horse manages to make the best out of its time together with the stuffed animal.
The post Horse Plays With Stuffed Toy In The Snow appeared first on Viral Viral Videos.
Adding assertions and sanity checks to your code is important, especially when you’re working in a loosely-typed language like JavaScript. Never assume the input parameters are correct, assert what they must be. Done correctly, they not only make your code safer, but also easier to understand.
Matthias’s co-worker… doesn’t exactly do that.
function checkPriceRangeTo(x, min, max) {
if (max == 0) {
max = valuesPriceRange.max
}
min = Math.min(min, max);
max = Math.max(min, max);
x = parseInt(x)
if (x == 0) {
x = 50000
}
//console.log(x, 'min:', min, 'max:', max);
return x >= min && x <= max
}
This code isn’t bad, per se. I knew a kid, Marcus, in middle school that wore the same green sweatshirt every day, and had a musty 19th Century science textbook that discussed phlogiston in his backpack. Over lunch, he was happy to strike up a conversation with you about the superiority of phlogiston theory over Relativity. He wasn’t bad, but he was annoying and not half as smart as he thought he was.
This code is the same. Sure, x might not be a numeric value, so let’s parseInt first… which might return NaN. But we don’t check for NaN, we check for 0. If x is 0, then make it 50,000. Why? No idea.
The real treat, though, is the flipping of min/max. If the calling code did this wrong (min=6,max=1) then instead of swapping them, which is obviously the intent, it instead makes them both equal to the lowest of the two.
In the end, Matthias has one advantage in dealing with this pest, that I didn’t have in dealing with Marcus. He could actually make it go away. I just had to wait until the next year, when we didn’t have lunch at the same time.
[Advertisement] Otter enables DevOps best practices by providing a visual, dynamic, and intuitive UI that shows, at-a-glance, the configuration state of all your servers. Find out more and download today!
There are certain chores you do as a dad that are pretty cool to do. Blowing leaves is one of them. But it can be scary too, especially when you have kids who like to […]
The post Just A Dad Unknowingly Blowing Leaves appeared first on Viral Viral Videos.
It can be boring sitting behind glass windows all day. People passing by, throwing a glance your way. So why wouldn’t you try to brighten up people’s days? A little wave can go a long […]
The post Bearded Dragon Waves Hello appeared first on Viral Viral Videos.
During the few months after getting my BS and before starting my MS, I worked for a bank that held lots of securities - and gold - in trust for others. There was a massive vault with multiple layers of steel doors, iron door grates, security access cards, armed guards, and signature comparisons (live vs pre-registered). It was a bit unnerving to get in there, so deep below ground, but once in, it looked very much like the Fort Knox vault scene in Goldfinger.
At that point, PCs weren't yet available to the masses and I had very little exposure to mainframes. I had been hired as an assistant to one of their drones who had been assigned to find all of the paper-driven-changes that had gone awry and get their books up to date.
To this end, I spent about a month talking to everyone involved in taking a customer order to take or transfer ownership of something, and processing the ledger entries to reflect the transaction. From this, I drew a simple flow chart, listing each task, the person(s) responsible, and the possible decision tree at each point.
Then I went back to each person and asked them to list all the things that could and did go wrong with transaction processing at their junction in the flow.
What had been essentially straight-line processing with a few small decision branches, turned out to be enough to fill a 30 foot long by 8 foot high wall of undesirable branches. This became absolutely unmanageable on physical paper, and I didn't know of any charting programs on the mainframe at that time, so I wrote the whole thing up with an index card at each junction. The "good" path was in green marker, and everything else was yellow (one level of "wrong") or red (wtf-level of "wrong").
By the time it was fully documented, the wall-o-index-cards had become a running joke. I invited the people (who had given me all of the information) in to view their problems in the larger context, and verify that the problems were accurately documented.
Then management was called in to view the true scope of their problems. The reason that the books were so snafu'd was that there were simply too many manual tasks that were being done incorrectly, cascading to deeply nested levels of errors.
Once we knew where to look, it became much easier to track transactions backward through the diagram to the last known valid junction and push them forward until they were both correct and current. A rather large contingent of analysts were then put onto this task to fix all of the transactions for all of the customers of the bank.
It was about the time that I was to leave and go back to school that they were talking about taking the sub-processes off the mainframe and distributing detailed step-by-step instructions for people to follow manually at each junction to ensure that the work flow proceeded properly. Obviously, more manual steps would reduce the chance for errors to creep in!
A few years later when I got my MS, I ran into one of the people that was still working there and discovered that the more-manual procedures had not only not cured the problem, but that entirely new avenues of problems had cropped up as a result.
[Advertisement] Easily create complex server configurations and orchestrations using both the intuitive, drag-and-drop editor and the text/script editor. Find out more and download today!
Reporting on location is harder than ever. Danger in looming on every corner, and even in nature nowadays criminals are on the rise. Watch as this reporter get viciously assaulted.
The post BBC Reporter Mobbed By Lemurs appeared first on Viral Viral Videos.
If you follow Trump news, you’re guaranteed some frisky oneliners and controversial statements. If you follow content that’s being made about his presidency, you’re guaranteed dying of laughter. Watch at your own risk.
The post A Bad Lip Reading Of Donald Trump appeared first on Viral Viral Videos.
At the end of 2016, Ian S. accepted a contract position at a large medical conglomerate. He was joining a team of 6 developers on a project to automate what was normally a 10,000-hour manual process of cross-checking spreadsheets and data files. The end result would be a Django server offering a RESTful API and MySQL backend.
"You probably won't be doing anything much for the first week, maybe even the first month," Ian's interviewer informed him.
Ian ignored the red flag and accepted the offer. He needed the experience, and the job seemed reasonable enough. Besides, there were only 2 layers of management to deal with: his boss Daniel, who led the team, and his boss' boss Jim.
The office was in an lavish downtown location. The first thing Ian learned was that nobody had assigned desks. Each day, everyone had to clean out their desks and return their computers and peripherals to lockers. Because team members needed to work closely together, everyone claimed the same desk every day anyway. This policy only resulted in frustration and lost time.
As if that weren't bad enough, the computers were also heavily locked down. Ian had to go through the company's own "app store" to install anything. This was followed by an approval process that could take a few days based on how often Jim went through his pending approvals. The one exception was VMWare Workstation. Because this app cost money, it involved a 2-week approval process. In the middle of December, everyone was off on holiday, making it impossible for Ian's team to get approvals or talk to anyone helpful. Thus Ian's only contributions that month were a couple of Visio diagrams and a Django "hello world" that Daniel had requested. (It wasn't as if Daniel could check his work, though. He didn't know anything about Python, Django, REST, MySQL, MVC, or any other technology relevant to the project.)
The company provided Ian a copy of Agile for Dummies, which seemed ironic in retrospect, as the team was forced to the spend entire first week of January breaking the next 6 months into 2-week sprints. They weren't allowed to leave sprints empty, and had to allocate 36-40 hours each week. They could only make stories for features, so no time was penciled in for bug fixes or paying off technical debt. These stories were then chopped into meaningless pieces ("Part 1", "Part 2", etc.) so they'd fit into their arbitrary timelines.
"This is why medical insurance is so expensive", Daniel remarked at one point, either trying to lighten the mood or stave off his pending insanity.
Later in January, Ian arrived one morning to find the rest of his team standing around confused. Their project was now dead at the hands of a VP who'd had it in for Jim. The company had a tenure process, so the VP couldn't just fire Jim, but he could make his life miserable. He reassigned all of Jim's teams that he didn't outright terminate, exiled Jim to New Jersey, and gave him nothing to do but approve timesheets. Meanwhile, Daniel was told not to bother coming in again.
"Don't worry," the powers-that-be said. "We don't usually terminate people here."
Ian's gapingly empty schedule was filled with a completely different task: "shadowing" someone in another state by screen-sharing and watching them work. The main problem with this arrangement was that Ian's disciple was a systems analyst, not a programmer.
Come February, Ian's new team was also terminated.
"We don't have a culture of layoffs," the powers-that-be assured him.
They were still intent on shoving Ian into a systems analyst position despite his requisite lack of experience. It was at that point that he gave up and moved on. He later heard that within a few months, the entire division had been fired.
[Advertisement] Release! is a light card game about software and the people who make it. Play with 2-5 people, or up to 10 with two copies - only $9.95 shipped!