| I l@ve RuBoard |
7.7 Checkbutton, Radiobutton, and ScaleThis section introduces three widget types -- the Checkbutton (a multiple-choice input widget), the Radionbutton (a single-choice device), and the Scale (sometimes known as a "slider"). All are variations on a theme, and somewhat related to simple buttons, so we'll explore them as a group here. To make these widgets more fun to play with, we'll reuse the dialogTable module shown in Example 7-8 to provide callbacks for widget selections (callbacks pop up dialog boxes). Along the way, we'll also use the Tkinter variables we just met to communicate with these widgets' state settings. 7.7.1 CheckbuttonsThe Checkbutton and Radiobutton widgets are designed to be associated with Tkinter variables: pushing the button changes the value of the variable, and setting the variable changes the state of the button it is linked to. In fact, Tkinter variables are central to the operation of these widgets:
Both kinds of buttons provide both command and variable options. The command option lets you register a callback to be run immediately on button-press events, much like normal Button widgets. But by associating a Tkinter variable with the variable option, you can also fetch or change widget state at any time, by fetching or changing the value of the widget's associated variable. Since it's a bit simpler, let's start with the Tkinter checkbutton. Example 7-22 creates the set of five, captured in Figure 7-26. To make this more useful, it also adds a button that dumps the current state of all checkbuttons, and attaches an instance of the Quitter button we built earlier in the tour. Example 7-22. PP2E\Gui\Tour\demoCheck.pyfrom Tkinter import * # get base widget set from dialogTable import demos # get canned dialogs from quitter import Quitter # attach a quitter object to "me" class Demo(Frame): def __init__(self, parent=None, **args): Frame.__init__(self, parent, args) self.pack() self.tools() Label(self, text="Check demos").pack() self.vars = [] for key in demos.keys(): var = IntVar() Checkbutton(self, text=key, variable=var, command=demos[key]).pack(side=LEFT) self.vars.append(var) def report(self): for var in self.vars: print var.get(), # current toggle settings: 1 or 0 print def tools(self): frm = Frame(self) frm.pack(side=RIGHT) Button(frm, text='State', command=self.report).pack(fill=X) Quitter(frm).pack(fill=X) if __name__ == '__main__': Demo().mainloop() Figure 7-26. demoCheck in actionIn terms of program code, checkbuttons resemble normal buttons; they are even packed within a container widget. Operationally, though, they are a bit different. As you can probably tell from this figure (and can better tell by running this live), a checkbutton works as a toggle -- pressing one changes its state from off to on (deselected to selected); or from on to off again. When a checkbox is selected, it has a checked display, and its associated IntVar variable has a value of 1; when deselected, its display is empty, and its IntVar has value 0. To simulate an enclosing application, the State button in this display triggers the script's report method to display the current values of all five toggles on the stdout stream. Here is the output after a few pushes: C:\...\PP2E\Gui\Tour>python demoCheck.py 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 1 0 1 1 0 1 0 0 1 0 1 0 0 1 1 Really, these are the values of the five Tkinter variables associated with the checkbuttons with variable options, but they give the buttons' values when queried. This script associates Intvar variables with each of checkbuttons in this display, since they are or 1 binary indicators. StringVars will work here too, although their get methods would return strings "0" or "1" (not integers), and their initial state is an empty string (not the integer 0). This widget's command option lets you register a callback to be run each time the button is pressed. To illustrate, this script registers a standard dialog demo call as a handler for each of the checkbuttons: pressing a button changes the toggle's state, but also pops up one of the dialog windows we visited earlier on this tour. Interestingly, you can run the report method interactively too. When working this way, widgets pop up as lines are typed and are fully active even without calling mainloop: C:\...\PP2E\Gui\Tour>python >>> from demoCheck import Demo >>> d = Demo() >>> d.report() 0 0 0 0 0 >>> d.report() 1 0 0 0 0 >>> d.report() 1 0 0 1 1 <IP_ADDRESS> Checkbuttons and variablesWhen I first studied this widget, my initial reaction was: So why do we need Tkinter variables here at all when we can register button-press callbacks? Linked variables may seem superfluous at first glance, but they simplify some GUI chores. Rather than asking you to accept this blindly, though, let me explain why. Keep in mind that a checkbuttons's command callback will be run on every press -- whether the press toggles the checkbutton to a selected or deselected state. Because of that, if you want to run an action immediately when a checkbutton is pressed, you will generally want to check the button's current value in the callback handler. Because there is no checkbutton "get" method for fetching values, you usually need to interrogate an associated variable to see if the button is on or off. Moreover, some GUIs simply let users set checkbuttons without running command callbacks at all, and fetch button settings at some later point in the program. In such a scenario, variables serve to automatically keep track of button settings. The demoCheck script's report method is representative of this latter approach. Of course, you could manually keep track of each button's state in press callback handlers too. Example 7-23 keeps its own list of state toggles, and updates it manually on command press callbacks. Example 7-23. PP2E\Gui\Tour\demo-check-manual.py# check buttons, the hard way (without variables) from Tkinter import * states = [] def onPress(i): # keep track of states states[i] = not states[i] # changes 0->1, 1->0 root = Tk() for i in range(10): chk = Checkbutton(root, text=str(i), command=(lambda i=i: onPress(i)) ) chk.pack(side=LEFT) states.append(0) root.mainloop() print states # show all states on exit The lambda here passes along the pressed button's index in the states list (or else we would need a separate callback function for each button). When run, this script makes the 10-checkbutton display in Figure 7-27. Figure 7-27. Manual checkbutton state windowManually maintained state toggles are updated on every button press, and are printed when the GUI exits (technically, when the mainloop call returns): C:\...\PP2E\Gui\Tour>python demo-check-manual.py [0, 0, 1, 0, 1, 0, 0, 0, 1, 0] This works, and isn't too horribly difficult to manage manually. But linked Tkinter variables make this task noticeably easier, especially if you don't need to process checkbutton states until some time in the future. This is illustrated in Example 7-24. Example 7-24. PP2E\Gui\Tour\demo-check-auto.py# check buttons, the easy way from Tkinter import * root = Tk() states = [] for i in range(10): var = IntVar() chk = Checkbutton(root, text=str(i), variable=var) chk.pack(side=LEFT) states.append(var) root.mainloop() # let Tkinter keep track print map((lambda var: var.get()), states) # show all states on exit This looks and works the same, but there is no command button-press callback handler at all, because toggle state is tracked by Tkinter automatically: C:\...\PP2E\Gui\Tour>python demo-check-auto.py [0, 0, 1, 0, 0, 0, 1, 0, 0, 0] The point here is that you don't necessarily have to link variables with checkbuttons, but your GUI life will be simpler if you do. 7.7.2 RadiobuttonsRadiobuttons are toggles too, but they are generally used in groups: just like the mechanical station selector pushbuttons on radios of times gone by, pressing one Radiobutton widget in a group automatically deselects the one pressed last. In other words, at most one can be selected at once. In Tkinter, associating all radiobuttons in a group with unique values and the same variable guarantees that at most one can ever be selected at a given time. Like checkbuttons and normal buttons, radiobuttons support a command option for registering a callback to handle presses immediately. Like checkbuttons, radiobuttons also have a variable attribute for associating single-selection buttons in a group and fetching the current selection at arbitrary times. In addition, radiobuttons have a value attribute that lets you tell Tkinter what value the button's associated variable should have when the button is selected. Because more than one radiobutton is associated with the same variable, you need to be explicit about each button's value (it's not just a 1 or toggle scenario). Example 7-25 demonstrates radiobutton basics. Example 7-25. PP2E\Gui\Tour\demoRadio.pyfrom Tkinter import * # get base widget set from dialogTable import demos # button callback handlers from quitter import Quitter # attach a quit object to "me" class Demo(Frame): def __init__(self, parent=None): Frame.__init__(self, parent) self.pack() Label(self, text="Radio demos").pack(side=TOP) self.var = StringVar() for (key, value) in demos.items(): Radiobutton(self, text=key, command=self.onPress, variable=self.var, value=key).pack(anchor=NW) Button(self, text='State', command=self.report).pack(fill=X) Quitter(self).pack(fill=X) def onPress(self): pick = self.var.get() print 'you pressed', pick print 'result:', demos[pick]() def report(self): print self.var.get() if __name__ == '__main__': Demo().mainloop() Figure 7-28 shows what this script generates when run. Pressing any of this window's radiobuttons triggers its command handler, pops up one of the standard dialog boxes we met earlier, and automatically deselects the button previously pressed. Like checkbuttons, radiobuttons are packed; this script packs them to the the top to arrange vertically, and then anchors each on the northwest corner of its allocated space so that they align well. Figure 7-28. demoRadio in actionLike the checkbutton demo script, this one also puts up a State button to run the class's report method, and show the current radio state (the button selected). Unlike the checkbutton demo, this script also prints the return values of dialog demo calls run as its buttons are pressed. Here is what the stdout stream looks like after a few presses and state dumps; states are shown in bold: C:\...\PP2E\Gui\Tour>python demoRadio.py you pressed Input result: 3.14 Input you pressed Open result: C:/PP2ndEd/examples/PP2E/Gui/Tour/demoRadio.py Open you pressed Query result: yes Query <IP_ADDRESS> Radiobuttons and variablesSo why variables here? For one thing, radiobuttons also have no "get" widget method to fetch the selection in the future. More importantly, in radiobutton groups, the value and variable settings turn out to be the whole basis of single-choice behavior. In fact, to make radiobuttons work normally at all, it's crucial that they all are associated with the same Tkinter variable, and all have distinct value settings. To truly understand why, though, you need to know a bit more about how radiobuttons and variables do their stuff. We've already seen that changing a widget changes its associated Tkinter variable, and vice versa. But it's also true that changing a variable in any way automatically changes every widget it is associated with. In the world of radiobuttons, pressing a button sets a shared variable, which in turn impacts other buttons associated with that variable. Assuming that all buttons have distinct values, this works as you expect: When a button press changes the shared variable to the pressed button's value, all other buttons are deselected, simply because the variable has been changed to a value not their own. This ripple effect is a bit subtle, but it might help to know that within a group of radiobuttons sharing the same variable, if you assign a set of buttons the same value, the entire set will be selected if any one of them is pressed. Consider Example 7-26 and Figure 7-29, for example; because radiobuttons 0, 3, 6, and 9 all have value (the remainder of division by 3), all are selected if any are selected (Figure 7-29). Example 7-26. PP2E\Gui\Tour\demo-radio-multi.py# see what happens when some buttons have same value from Tkinter import * root = Tk() var = StringVar() for i in range(10): rad = Radiobutton(root, text=str(i), variable=var, value=str(i % 3)) rad.pack(side=LEFT) root.mainloop() Figure 7-29. Radiobuttons gone bad?If you press 1, 4, or 7 now, all three of these are selected, and any existing selections are cleared (they don't have value "1"). That's not normally what you want, so be sure to give each button the same variable but a unique value if you want radiobuttons to work as expected. In the demoRadio script, for instance, the name of the demo provides a naturally unique value for each button. <IP_ADDRESS> Radiobuttons without variablesIn Example 7-27, too, you could implement a single-selection model without variables, by manually selecting and deselecting widgets in the group, in a callback handler of your own. On each press event, for example, you could issue deselect calls for every widget object in the group and select the one pressed. Example 7-27. PP2E\Gui\Tour\demo-radio-manual.py# radio buttons, the hard way (without variables) # note that deselect for radio buttons simply sets the button's # associated value to a null string, so we either need to still # give buttons unique values, or use checkbuttons here instead; from Tkinter import * state = '' buttons = [] def onPress(i): global state state = i for btn in buttons: btn.deselect() buttons[i].select() root = Tk() for i in range(10): rad = Radiobutton(root, text=str(i), value=str(i), command=(lambda i=i: onPress(i)) ) rad.pack(side=LEFT) buttons.append(rad) root.mainloop() print state # show state on exit This works -- it creates a 10-radiobutton window that looks just like the one in Figure 7-29, but implements a single-choice radio style interface, with current state available in a global Python variable printed on script exit. By associating Tkinter variables and unique values, though, you can let Tkinter do all this work for you, as shown in Example 7-28. Example 7-28. PP2E\Gui\Tour\demo-radio-auto.py# radio buttons, the easy way from Tkinter import * root = Tk() # IntVars work too var = IntVar() # state = var.get() for i in range(10): rad = Radiobutton(root, text=str(i), value=i, variable=var) rad.pack(side=LEFT) root.mainloop() print var.get() # show state on exit This works the same, but is a lot less to type and debug. Notice that this script associates the buttons with an IntVar, the integer type sibling of StringVar; as long as button values are unique, integers work fine for radiobuttons too. <IP_ADDRESS> Hold on to your variablesOne minor word of caution: you should generally hold on to the Tkinter variable object used to link radiobuttons for as long as the radiobuttons are displayed. Assign it to a module global variable, store it in a long-lived data structure, or save it as an attribute of a long-lived class object as done by demoRadio -- just as long as you retain a reference to it somehow. You normally will fetch state anyhow, so it's unlikely that you'll ever care about what I'm about to tell you. But in the current Tkinter, variable classes have a __del__ destructor that automatically unsets a generated Tk variable when the Python object is reclaimed (i.e., garbage-collected). The upshot is that your radiobuttons may all be deselected if the variable object is collected, at least until the next press resets the Tk variable to a new value. Example 7-29 shows one way to trigger this. Example 7-29. PP2E\Gui\Tour\demo-radio-clear.py# hold on to your radio variables (an obscure thing, indeed) from Tkinter import * root = Tk() def radio1(): # local vars are temporary #global tmp # making it global fixes the problem tmp = IntVar() for i in range(10): rad = Radiobutton(root, text=str(i), value=i, variable=tmp) rad.pack(side=LEFT) tmp.set(5) radio1() root.mainloop() This should come up with button 5 selected initially, but doesn't. The variable referenced by local tmp is reclaimed on function exit, the Tk variable is unset, and the 5 setting is lost (all buttons come up unselected). These radiobuttons work fine, though, one you start pressing them, because that resets the Tk variable. Uncommenting the global statement here makes 5 start out set, as expected. Of course, this is an atypical example -- as coded, there is no way to know which button is pressed, because the variable isn't saved (and command isn't set). In fact, this is so obscure that I'll just refer you to demo-radio-clear2.py on the CD for an example that works hard to trigger this oddity in other ways. You probably won't care, but you can't say that I didn't warn you if you ever do. 7.7.3 Scales (Sliders)Scales (sometimes called "sliders") are used to select among a range of numeric values. Moving the scale's position with mouse drags or clicks moves the widget's value among a range of integers, and triggers Python callbacks if registered. Like checkbuttons and radiobuttons, scales have both a command option for registering an event-driven callback handler to be run right away when the scale is moved, as well as a variable option for associating a Tkinter variable that allows the scale's position to be fetched and set at arbitrary times. You can process scale settings when they are made, or let the user pick a setting for later use. In addition, scales have a third processing option -- get and set methods that scripts may call to access scale values directly without associating variables. Because scale command movement callbacks also get the current scale setting value as an argument, it's often enough just to provide a callback for this widget, without resorting to either linked variables or get/set method calls. To illustrate the basics, Example 7-30 makes two scales -- one horizontal and one vertical -- and links them with an associated variable to keep them in sync. Example 7-30. PP2E\Gui\Tour\demoScale.pyfrom Tkinter import * # get base widget set from dialogTable import demos # button callback handlers from quitter import Quitter # attach a quit frame to me class Demo(Frame): def __init__(self, parent=None): Frame.__init__(self, parent) self.pack() Label(self, text="Scale demos").pack() self.var = IntVar() Scale(self, label='Pick demo number', command=self.onMove, # catch moves variable=self.var, # reflects position from_=0, to=len(demos)-1).pack() Scale(self, label='Pick demo number', command=self.onMove, # catch moves variable=self.var, # reflects position from_=0, to=len(demos)-1, length=200, tickinterval=1, showvalue=YES, orient='horizontal').pack() Quitter(self).pack(side=RIGHT) Button(self, text="Run demo", command=self.onRun).pack(side=LEFT) Button(self, text="State", command=self.report).pack(side=RIGHT) def onMove(self, value): print 'in onMove', value def onRun(self): pos = self.var.get() print 'You picked', pos pick = demos.keys()[pos] # map from position to key print demos[pick]() def report(self): print self.var.get() if __name__ == '__main__': print demos.keys() Demo().mainloop() Besides value access and callback registration, scales have options tailored to the notion of a range of selectable values, most of which are demonstrated in this example's code:
Note that scales are also packed in their container, just like other Tkinter widgets. Let's see how these ideas translate in practice; Figure 7-30 shows the window you get if you run this script live on Windows (you get a similar one on Unix and Macs). Figure 7-30. demoScale in actionFor illustration purposes, this window's State button shows the scales' current values, and "Run demo" runs a standard dialog call as before using the integer value of the scales to index the demos table. The script also registers a command handler that fires every time either of the scales is moved, and prints their new positions. Here is a set of messages sent to stdout after a few moves, demo runs (italic), and state requests (bold): C:\...\PP2E\Gui\Tour>python demoScale.py ['Error', 'Input', 'Open', 'Query', 'Color'] in onMove 0 in onMove 0 in onMove 1 1 in onMove 2 You picked 2 C:/PP2ndEd/examples/PP2E/Gui/Tour/demoScale.py in onMove 3 3 You picked 3 yes <IP_ADDRESS> Scales and variablesAs you can probably tell, scales offer a variety of ways to process their selections: immediately in move callbacks, or later by fetching current position with variables or scale method calls. In fact, Tkinter variables aren't needed to program scales at all -- simply register movement callbacks, or call the scale get method to fetch scale values on demand as in the simpler scale example in Example 7-31. Example 7-31. PP2E\Gui\Tour\demo-scale-simple.pyfrom Tkinter import * root = Tk() scl = Scale(root, from_=-100, to=100, tickinterval=50, resolution=10) scl.pack(expand=YES, fill=Y) def report(): print scl.get() Button(root, text='state', command=report).pack(side=RIGHT) root.mainloop() Figure 7-31 shows two instances of this program running on Windows -- one stretched and one not (the scales are packed to grow vertically on resizes). Its scale displays a range from -100 to 100, uses the resolution option to adjust the current position up or down by 10 on every move, and sets the tickinterval option to show values next to the scale in increments of 50. When you press the State button in this script's window, it calls the scale's get method to display the current setting, without variables or callbacks of any kind: C:\...\PP2E\Gui\Tour>python demo-scale-simple.py 0 60 -70 Figure 7-31. A simple scale without variablesFrankly, the only reason Tkinter variables are used in the demoScale script at all is to synchronize scales. To make the demo interesting, this script associates the same Tkinter variable object with both scales. As we learned in the last section, changing a widget changes its variable, but changing a variable also changes all the widgets it is associated with. In the world of sliders, moving the slide updates that variable, which in turn might update other widgets associated with the same variable. Because this script links one variable with two scales, it keeps them automatically in sync: moving one scale moves the other too, because the shared variable is changed in the process and so updates the other scale as a side effect. Linking scales like this may or may not be typical of your applications (and borders on deep magic), but it's a powerful tool once you get your mind around it. By linking multiple widgets on a display with Tkinter variables, you can keep them automatically in sync, without making manual adjustments in callback handlers. On the other hand, the synchronization could be implemented without a shared variable at all by calling one scale's set method from a move callback handler of the other. I'll leave such a manual mutation as a suggested exercise, though. One person's deep magic might be another's evil hack. |
| I l@ve RuBoard |


Id: 269
Name: Presidentress of The Mega Gargantuans
Status: Alive
Species: Humanoid
Type: Mega Gargantuan
Gender: Female
OriginName: Mega Gargantuan Kingdom
OriginUrl: https://rickandmortyapi.com/api/location/56
LocationName: Mega Gargantuan Kingdom
LocationUrl: https://rickandmortyapi.com/api/location/56
Image: https://rickandmortyapi.com/api/character/avatar/269.jpeg
Episode: ['https://rickandmortyapi.com/api/episode/31']
Url: https://rickandmortyapi.com/api/character/269
Created: 2017-12-31T14:01:44.995Z


Jonathan, in spite of all the accomplishments that he has acheived was born into a relatively impoverished family. Born in Pasuruan, Indonesia his family lived a rough life not being able to have the luxuries like in the first world countries. Growing up however, Jonathan wasn't satisfied with the current position and wanted more!
Against all odds, Jonathan took up the challenge of bettering the lives of those who he loves and set his eyes on the Western World. Continuously pushing himeself Jonathan travelled and stayed in Australia for a couple years before finally settling in the United States.
After settling into life in the States, Jonathan and his wife decided to open up a business in order to bring in income. His wife decided to start up an assisted living. After suffering losses for seven years, life finally looked brighter. Throughout the seven years however Jonathan and his family tried their best to stay positive and made it through.
Recently Jonathan decided to open a second business, this time being a learning center called Eye Level, his wife still runs the assited living and they are now a happy family with three kids. Jonathan has been a role model for many dads around the world, tanking through the hard times and keeping the family together!


The second table allows you to limit the number of concurrent logins by clients of each class. For each class you can enter the maximum simultaneous logins, the days and times at which the maximum is enforced (in UUCP style, like MoTuTh0800-1700), and an error message file to display to clients when the limit is reached.
The third table allows you to set per-session file and data transfer limits. For each limit, you must choose whether it applied to files or bytes transferred, the transfer direction the limit applies to, whether the limit applies to just file transfers or all data, and the class of users the limit is for.
The fourth table allows you to deny access to certain files. For each file
you need to enter an absolute path, choose whether the path is relative
to the chroot directory (for anonymous and guest users) and select
the user classes this restriction applies to. If a file to deny ends with
a /, the FTP server will deny access to all files in that directory.
Similarly, the fifth table allows you to grant access to files that would
be otherwise denied by the table above.


I am pleased to announce the support for complex-domain linear programs (LPs) in Convex.jl. As one of the Google Summer of Code students under The Julia Language, I had proposed to implement the support for complex semidefinite programming. In the first phase of project, I started by tackling the problem of complex-domain LPs where in first subphase, I had announced the support for complex coefficients during JuliaCon'16 and now I take this opportunity to announce the support for complex variables in LPs.
Complex-domain LPs consist of a real linear objective function, real linear inequality constraints, and real and complex linear equality constraints.
In order to enable complex-domain LPs, we came up with these ideas:
We redefined the conic_form! of every affine atom to accept complex arguments.
Every complex variable z was internally represented as z = z1 + i*z2
, where z1 and z2 are real.
We introduced two new affine atoms real and imag which return the real and the imaginary parts of the complex variable respectively.
transpose and ctranspose perform differently on complex variables so a new atom CTransposeAtom was created.
A complex-equality constraint RHS = LHS can be decomposed into two corresponding real equalities constraint real(RHS) = real(LHS) and imag(RHS) = imag(LHS)
After above changes were made to the codebase, we wrote two use cases to demonstrate the usability and the correctness of our idea which I am presenting below:
# Importing Packages
Pkg.clone("https://github.com/Ayush-iitkgp/Convex.jl/tree/gsoc2")
using Convex
# Complex LP with real variable
n = 10 # variable dimension (parameter)
m = 5 # number of constraints (parameter)
xo = rand(n)
A = randn(m,n) + im*randn(m,n)
b = A * xo
# Declare a real variable
x = Variable(n)
p1 = minimize(sum(x), A*x == b, x>=0)
# Notice A*x==b is complex equality constraint
solve!(p1)
x1 = x.value
# Let's now solve by decomposing complex equality constraint into the corresponding real and imaginary part.
p2 = minimize(sum(x), real(A)*x == real(b), imag(A)*x==imag(b), x>=0)
solve!(p2)
x2 = x.value
x1==x2 # should return true
# Let's now consider an example using a complex variable
# Complex LP with complex variable
n = 10 # variable dimension (parameter)
m = 5 # number of constraints (parameter)
xo = rand(n)+im*rand(n)
A = randn(m,n) + im*randn(m,n)
b = A * xo
# Declare a complex variable
x = ComplexVariable(n)
p1 = minimize(real(sum(x)), A*x == b, real(x)>=0, imag(x)>=0)
solve!(p1)
x1 = x.value
xr = Variable(n)
xi = Variable(n)
p2 = minimize(sum(xr), real(A)*xr-imag(A)*xi == real(b), imag(A)*xr+real(A)*xi == imag(b), xr>=0, xi>=0)
solve!(p2)
x1== xr.value + im*xi.value # should return true
List of all the affine atoms are as follows:
addition, substraction, multiplication, division
indexing and slicing
k-th diagonal of a matrix
construct diagonal matrix
transpose and ctranspose
stacking
sum
trace
conv
real and imag
Now, I am working towards implementing complex-domain second order conic programming. Meanwhile, I invite the Julia community to play around with the complex-domain LPs. The link to the development branch is here.
Looking forward to your suggestions!
Special thanks to my mentors Madeleine Udell and Dvijotham Krishnamurthy!


Index
A B C D E F G H I J L M N O P R S T U V W X Y
All Classes|All Packages
All Classes|All Packages
All Classes|All Packages
M
- main(String[]) - Static method in class it.polimi.ingsw.ClientApp
- main(String[]) - Static method in class it.polimi.ingsw.ServerApp
- MATCH_INFO - it.polimi.ingsw.network.message.MessageType
- MatchInfoMessage - Class in it.polimi.ingsw.network.message
-
Message which contains information about the current status of the match.
- MatchInfoMessage(String, MessageType, List<String>, List<ReducedGod>, List<Color>, String) - Constructor for class it.polimi.ingsw.network.message.MatchInfoMessage
- MAX_COLUMNS - Static variable in class it.polimi.ingsw.model.board.Board
- MAX_LEVEL - Static variable in class it.polimi.ingsw.model.board.Space
- MAX_PLAYERS - Static variable in class it.polimi.ingsw.model.Game
- MAX_ROWS - Static variable in class it.polimi.ingsw.model.board.Board
- MenuSceneController - Class in it.polimi.ingsw.view.gui.scene
-
This class implements the main menu scene.
- MenuSceneController() - Constructor for class it.polimi.ingsw.view.gui.scene.MenuSceneController
- Message - Class in it.polimi.ingsw.network.message
-
Abstract message class which must be extended by each message type.
- MessageType - Enum in it.polimi.ingsw.network.message
-
This enum contains all the message type available and used by the server and clients.
- MIN_LEVEL - Static variable in class it.polimi.ingsw.model.board.Space
- move(Position) - Method in class it.polimi.ingsw.model.player.Worker
-
Move the Worker to the given position.
- MOVE - it.polimi.ingsw.model.enumerations.PlayerState
- MOVE - it.polimi.ingsw.model.enumerations.XMLName
- MOVE - it.polimi.ingsw.network.message.MessageType
- MOVE_FX - it.polimi.ingsw.network.message.MessageType
- move_moveHistory() - Method in class it.polimi.ingsw.model.player.WorkerTest
- MoveAgainDecorator - Class in it.polimi.ingsw.model.effects
-
Decorator to add an extra move to the simple effect.
- MoveAgainDecorator(Effect, Map<String, String>, boolean) - Constructor for class it.polimi.ingsw.model.effects.MoveAgainDecorator
-
Default constructor.
- MoveAgainDecoratorTest - Class in it.polimi.ingsw.model.effects
-
This class tests the
MoveAgainDecorator
methods. - MoveAgainDecoratorTest() - Constructor for class it.polimi.ingsw.model.effects.MoveAgainDecoratorTest
- MoveLockDecorator - Class in it.polimi.ingsw.model.effects
-
Decorator to add a move lock to the simple effect.
- MoveLockDecorator(Effect, Map<String, String>, MoveType) - Constructor for class it.polimi.ingsw.model.effects.MoveLockDecorator
-
Default constructor.
- MoveLockDecoratorTest - Class in it.polimi.ingsw.model.effects
-
This class tests the
MoveLockDecorator
methods. - MoveLockDecoratorTest() - Constructor for class it.polimi.ingsw.model.effects.MoveLockDecoratorTest
- MoveOverDecorator - Class in it.polimi.ingsw.model.effects
-
Decorator to add a custom move to the simple effect.
- MoveOverDecorator(Effect, Map<String, String>, boolean, boolean) - Constructor for class it.polimi.ingsw.model.effects.MoveOverDecorator
-
Default constructor.
- MoveOverDecoratorTest - Class in it.polimi.ingsw.model.effects
-
This class tests the
MoveOverDecorator
methods. - MoveOverDecoratorTest() - Constructor for class it.polimi.ingsw.model.effects.MoveOverDecoratorTest
- movePhase(boolean) - Method in class it.polimi.ingsw.controller.TurnController
-
Ask to Active Player where to Move the Active Worker.
- MoveType - Enum in it.polimi.ingsw.model.enumerations
-
This enum contains all type of move that a worker can perform.
- MoveWinDecorator - Class in it.polimi.ingsw.model.effects
-
Decorator to add a move win condition to the simple effect.
- MoveWinDecorator(Effect, Map<String, String>, MoveType, int) - Constructor for class it.polimi.ingsw.model.effects.MoveWinDecorator
-
Default constructor.
- MoveWinDecoratorTest - Class in it.polimi.ingsw.model.effects
-
This class tests the
MoveWinDecorator
methods. - MoveWinDecoratorTest() - Constructor for class it.polimi.ingsw.model.effects.MoveWinDecoratorTest
- moveWorker() - Method in class it.polimi.ingsw.model.board.BoardTest
- moveWorker() - Method in class it.polimi.ingsw.model.GameTest
- moveWorker(Worker, Position) - Method in class it.polimi.ingsw.model.board.Board
-
Moves a worker to the given
Position
. - moveWorker(Worker, Position) - Method in class it.polimi.ingsw.model.Game
-
Moves a worker to the given
Position
.
All Classes|All Packages


Here you can read our handy guide about what to do when.
This page was written by<EMAIL_ADDRESS>for W3schools.
Top of page


From
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
To
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
Date
Class
Travellers
SEARCH
From
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
To
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
Date
From
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
To
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
Date
From
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
To
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
Date
From
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
To
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
Date
From
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
To
{{option.IATA}}
{{option.Airport}}
{{option.Country}}
Date
SEARCH


If you are experiencing a live threatening experience please call 911
Medical
Mental Health
Domestic Violence
Human Trafficking
Sex Trafficking
Shelter
Affordable Housing
Transitional Housing
Permanent Supportive Housing
Hot meals
Food Pantries
EBT Food
EBT Restaurant
WIC
Community Clinics
STD Testing and Treatment
Immunization
Crisis Support
Adult Mental Health
Children's Mental Health
Substance Use
Support Groups
Vocational Training
School Districts
Community Colleges
EBT Cash
Cancel
Sac SOS is a continuously-updated list of free and low-cost resources available to Sacramento residents
search
Youth
Emergency
Safety
Housing/Shelter
Food
Healthcare
Legal Service
Employment
Education/Training
Public Assistance
Open Today All
These are the listings you marked as favorite
{{resource.description}}
{{resource.address.address_1}}, {{resource.address.city}} {{phone.number}} {{phone.number_type}} {{resource.website}}
Open {{resource.days}} {{resource.hours}}
{{service.description}}
{{service.application_process}}


vignettes/opendatascot.Rmd
opendatascot.Rmd
Use opendatascot to download data from statistics.gov.scot with a single line of R code. opendatascot removes the need to write SPARQL code; you simply need the URI of a dataset. opendatascot can be used interactively, or as part of a reproducible analytical pipeline.
You can download an entire dataset, or filter by date and/or geography. We recommend filtering large datasets. If you require a full download of a large dataset, you may need to contact statistics.gov.scot.
You will always need the last part of the URI for your dataset. Find this on the statistics.gov.scot web page for your dataset (in the API tab). For example, the full URI for Average Household Size is Average Household Size:
http://statistics.gov.scot/data/average-household-size
you just need the last part:
average-household-size
Once you have the last part of the URI, set this as the dataset
parameter for ods_dataset()
:
household_size <- ods_dataset(dataset = "average-household-size")
#> Parsed with column specification:
#> cols(
#> FeatureCode = col_character(),
#> DateCode = col_integer(),
#> Measurement = col_character(),
#> Units = col_character(),
#> Value = col_double()
#> )
head(household_size)
#> # A tibble: 6 x 5
#> FeatureCode DateCode Measurement Units Value
#> <chr> <int> <chr> <chr> <dbl>
#> 1 S12000039 2015 Ratio People Per Household 2.09
#> 2 S12000039 2010 Ratio People Per Household 2.14
#> 3 S12000039 2005 Ratio People Per Household 2.21
#> 4 S12000039 2012 Ratio People Per Household 2.13
#> 5 S12000039 2007 Ratio People Per Household 2.18
#> 6 S12000039 2006 Ratio People Per Household 2.19
Filtering is useful for large data sets. The filtering parameters for ods_dataset()
are:
start_date
end_date
geography
Use either start_date
OR end_date
to filter datapoints before or after a certain date:
household_size_2010_onwards <- ods_dataset(dataset = "average-household-size",
start_date = 2010)
head(household_size_2010_onwards)
#> refArea refPeriod measureType value
#> 1 Dumfries and Galloway 2003 Ratio 2.25
#> 2 East Ayrshire 2003 Ratio 2.32
#> 3 East Lothian 2003 Ratio 2.32
#> 4 North Lanarkshire 2003 Ratio 2.35
#> 5 Angus 2003 Ratio 2.24
#> 6 Dundee City 2003 Ratio 2.09
Use start_date
AND end_date
to filter datapoints within a certain timeframe.
Specify a single geography using an S code:
household_size_S12000039 <- ods_dataset(dataset = "average-household-size",
geography = "S12000039")
head(household_size_S12000039)
#> refArea refPeriod measureType value
#> 1 Dumfries and Galloway 2003 Ratio 2.25
#> 2 East Ayrshire 2003 Ratio 2.32
#> 3 East Lothian 2003 Ratio 2.32
#> 4 North Lanarkshire 2003 Ratio 2.35
#> 5 Angus 2003 Ratio 2.24
#> 6 Dundee City 2003 Ratio 2.09
sessionInfo()
#> R version 3.5.2 (2018-12-20)
#> Platform: x86_64-pc-linux-gnu (64-bit)
#> Running under: Ubuntu 18.04.2 LTS
#>
#> Matrix products: default
#> BLAS: /usr/lib/x86_64-linux-gnu/blas/libblas.so.3.7.1
#> LAPACK: /usr/lib/x86_64-linux-gnu/lapack/liblapack.so.3.7.1
#>
#> locale:
#> [1] LC_CTYPE=en_GB.UTF-8 LC_NUMERIC=C
#> [3] LC_TIME=en_GB.UTF-8 LC_COLLATE=en_GB.UTF-8
#> [5] LC_MONETARY=en_GB.UTF-8 LC_MESSAGES=en_GB.UTF-8
#> [7] LC_PAPER=en_GB.UTF-8 LC_NAME=C
#> [9] LC_ADDRESS=C LC_TELEPHONE=C
#> [11] LC_MEASUREMENT=en_GB.UTF-8 LC_IDENTIFICATION=C
#>
#> attached base packages:
#> [1] stats graphics grDevices utils datasets methods base
#>
#> other attached packages:
#> [1] opendatascot_<IP_ADDRESS>00 SPARQL_1.16 RCurl_1.95-4.11
#> [4] bitops_1.0-6 XML_3.98-1.16
#>
#> loaded via a namespace (and not attached):
#> [1] Rcpp_0.12.18 rstudioapi_0.8 knitr_1.20 xml2_1.2.0
#> [5] magrittr_1.5 roxygen2_6.1.1 hms_0.4.2 MASS_7.3-51.1
#> [9] R6_2.3.0 rlang_0.2.2 fansi_0.3.0 stringr_1.3.1
#> [13] tools_3.5.2 utf8_1.1.4 cli_1.0.0 htmltools_0.3.6
#> [17] commonmark_1.5 yaml_2.2.0 rprojroot_1.3-2 digest_0.6.17
#> [21] assertthat_0.2.0 tibble_1.4.2 pkgdown_1.1.0 crayon_1.3.4
#> [25] readr_1.1.1 fs_1.2.6 curl_3.2 memoise_1.1.0
#> [29] evaluate_0.12 rmarkdown_1.10 stringi_1.2.4 pillar_1.3.0
#> [33] compiler_3.5.2 desc_1.2.0 backports_1.1.2 pkgconfig_2.0.2


Class Container
The standard IOC container class in Rezolver.
Implements
Inherited Members
Namespace: Rezolver
Assembly: Rezolver.dll
Syntax
public class Container : CachingContainerBase, IContainer, IScopeFactory, IServiceProvider, IRootTargetContainer, ITargetContainer, ICovariantTypeIndex
Remarks
All of this class' functionality is inherited through CachingContainerBase and its base classes.
Note that it doesn't implement lifetime scoping (although you can create a lifetime scope from it by calling its CreateScope() method).
Also note that the class implements ITargetContainer by wrapping the Targets property inherited from ContainerBase.
The reason for this is simplicity: in many applications, you'll want to simply create a new container, register services into it, and then start using it.
Configuration
Rezolver uses a configuration callback mechanism for pre-registering services or pre-configuring containers for certain types via the IContainerConfig interface. This is similar to the ITargetContainerConfig interface that's used by TargetContainer to provide functionality such as automatic enumerable injection out of the box, except it focuses specifically on configuring the container itself, rather than just registrations.
If you don't provide a config on construction, then the DefaultConfig will be used.
Constructors
| Improve this Doc View SourceContainer(IRootTargetContainer)
Constructs a new instance of the Container class using the given target container (or a new TargetContainer if not provided). No IContainerConfig will be used, leaving the deriving class free to do so.
Declaration
protected Container(IRootTargetContainer targets)
Parameters
| Type | Name | Description |
|---|---|---|
| IRootTargetContainer | targets | Optional. Contains the targets that will be used as the source of registrations for the container. If not provided, then a new TargetContainer will be created. |
Remarks
This constructor must be used by derived types in order to avoid apply any configuration before they are initialised.
In order to apply configuration, derived types must declare their own constructor which accepts an IContainerConfig, and apply it (or the DefaultConfig as a default) after performing all initialisation.
Container(IRootTargetContainer, IContainerConfig)
Constructs a new instance of the Container class.
Declaration
public Container(IRootTargetContainer targets = null, IContainerConfig config = null)
Parameters
| Type | Name | Description |
|---|---|---|
| IRootTargetContainer | targets | Optional. The target container whose registrations will be used for dependency lookup when Resolve(IResolveContext) (and other operations) is called. If not provided, a new TargetContainer instance is constructed. This will ultimately be available to derived types, after construction, through the Rezolver.Targets property. |
| IContainerConfig | config | Can be null. Configuration to apply to this container (and, potentially its Rezolver.Targets). If not provided, then the DefaultConfig will be used. |
Remarks
Note to inheritors - this constructor throws an InvalidOperationException if used by a derived class, because the application of configuration to the container will likely cause virtual methods to be called. Instead, you should declare your own constructor with the same signature which chains instead to the Container(IRootTargetContainer) protected constructor; and then you should apply the configuration yourself in that constructor (falling back to DefaultConfig if null).
Properties
| Improve this Doc View SourceDefaultConfig
The default container config used by all new containers. You can add/remove configurations from this collection to change the defaults which are applied to new container instances; or you can supply an explicit configuration when creating your container.
Declaration
public static CombinedContainerConfig DefaultConfig { get; }
Property Value
| Type | Description |
|---|---|
| CombinedContainerConfig |
Remarks
The configurations present in this collection by default will set up the expression target compiler and extend the automatic enumerable injection functionality so that the OverridingContainer class can produce enumerables which are made up of targets registered in both the overriding container and its inner container.


Education
|
|
Experience
|
-
Mavenlink - Full Stack Software Engineer (May 2014 - Dec 2015)
Enterprise web application experience. Mavenlink is a project management SAAS company that integrates project management with project financing. Experience working on a large team that had to maintain and create new features while ensuring reliability for a large user base. Experience with a large scale Ruby-on-Rails codebase and Marionette.js.
-
Taskflow.io - Founder (April 2012 - May 2014)
Founded a company that created a visual programming language to automate business processes. Used Ruby-on-Rails and Backbone.js. Taskflow.io
-
Discover Card - Front-end Part Time Contractor (Oct 2011 - May 2012)
Worked with a marketing team transforming PDF's into interactive websites.
-
Wellspring Worldwide - Software Engineer (June 2011 - April 2012)
Enterprise web application experience. Wellspring Worldwide is a technology transfer SAAS company. Clients included research labs, universities, and NASA. Worked on the Wellspring application and created their mobile apps to aid documenting in a research environment. Experience with iOS and PHP.
-
Punchkick Interactive - Software Engineer (June 2010 - June 2011)
Mobile web experience. Punchkick Interactive is a mobile web focused software contracting firm. Led the team that created m.harley-davidson.com. Created a number of fortune 500 mobile recruiting websites. Used the Cake PHP and Zend PHP frameworks.
|
Activities
|
-
Electronics tinkering
Projects include a 40k lumen flashlight, Off-roading computer, and a 1000 watt LED RGB amplifier.
-
Off-roading and dirt biking
Modifications to suspension, electronics, engine, and frame.
-
Multicopter building and flying
Built 4 mulicopters. Created rcbinder.com to share builds.
-
Eagle Scout
|


Original plot with no configuration
ggplot2 style configuration
signal determining base font size
Title, subtitle and group encoding (hover pointer over subtitle)
Title encoding using deprecated tiEncode
(should generate new
title element encoding with blue text for title only).
Subtitle configuration
Unconfigured event spec
Dragging disabled via config
Bar chart with horizontal axis ticks aligned to band extent and horizontal axis displaced by 4 pixels


Welcome! “Media for everyone” is a research project that implements best practices to make a website fully accessible for everyone.


--- title: Data Source Fetchers keywords: fastai sidebar: home_sidebar nb_path: "000_data.ipynb" ---
Ideally the DATA_PATH would be configurable
pd.options.display.max_columns = 200
pd.options.display.max_colwidth = 100
pd.options.display.html.use_mathjax = False
def fetch_from_kaggle(dataset: str, filename: str, data_path: Path = DATA_PATH, force: bool = False) -> pd.DataFrame:
"""Loads single dataset from Kaggle, downloading if necessary.
Requires Kaggle API credentials: https://github.com/Kaggle/kaggle-api#api-credentials
Intermediate files are stored in data_path.
"""
from kaggle.api.kaggle_api_extended import KaggleApi
dest = Path(data_path) / (urllib.parse.quote(filename) + '.zip')
if force or not dest.exists():
Path(data_path).mkdir(exist_ok=True, parents=True)
kaggle = KaggleApi()
kaggle.authenticate()
kaggle.dataset_download_file(dataset, filename, path=data_path)
return pd.read_csv(dest)
Progress Bar Taken from https://github.com/tqdm/tqdm/blob/master/examples/tqdm_wget.py
TODO: Don't allow partial/corrupted downloads
Data can be automatically extracted using job-advert-analysis; just need somewhere suitable to store the output.
data_au_jobs()
Should be quick on the second load
%time data_au_jobs()
The commands ending in _kaggle
require Kaggle's API Credentials to be set up.
A mirror of the CC licenced data is provided without the _kaggle
suffix.
CC BY-NC-SA 4.0
def data_wine_reviews_kaggle(data_path: Path = DATA_PATH, force: bool = False) -> pd.DataFrame:
"""Retrieves Wine Reivews Data
Requires Kaggle Credentials
License: CC BY-NC-SA 4.0
See https://www.kaggle.com/zynicide/wine-reviews
"""
return fetch_from_kaggle('zynicide/wine-reviews', 'winemag-data-130k-v2.csv', data_path=data_path)
data_wine_reviews()
CC BY-SA 4.0
def data_wiki_movies_kaggle(data_path: Path = DATA_PATH, force:bool = False) -> pd.DataFrame:
"""Movie Summaries from Wikipedia
Requires Kaggle Credentials
License: CC BY-SA 4.0
See https://www.kaggle.com/jrobischon/wikipedia-movie-plots
"""
return fetch_from_kaggle('jrobischon/wikipedia-movie-plots', 'wiki_movie_plots_deduped.csv', data_path=data_path, force=force)
data_wiki_movies()
def data_women_clothing_reviews_kaggle(data_path: Path = DATA_PATH, force:bool = False) -> pd.DataFrame:
"""Women's E-commerce Clothing Reviews
Requires Kaggle credentials
License: CC0
https://www.kaggle.com/nicapotato/womens-ecommerce-clothing-reviews
"""
return fetch_from_kaggle('nicapotato/womens-ecommerce-clothing-reviews', 'Womens Clothing E-Commerce Reviews.csv', data_path, force=force)
data_women_clothing_reviews()
def data_au_election_2019_tweets_kaggle(data_path: Path = DATA_PATH, force:bool = False) -> pd.DataFrame:
"""Tweets from the 2019 Australian Elections
Collected from Twitter API keyword search betwen 2019-05-10 and 2019-05-20.
Requires Kaggle credentials
License: CC0: Public Domain
See https://www.kaggle.com/taniaj/australian-election-2019-tweets
"""
return fetch_from_kaggle('taniaj/australian-election-2019-tweets', 'auspol2019.csv', data_path, force=force)
data_au_election_2019_tweets()
Other interesting datasets (To consider):
https://www.kaggle.com/andrewmvd/okcupid-profiles
CC0 tboyle10/medicaltranscriptions mtsamples.csv
https://www.kaggle.com/andrewmvd/okcupid-profiles/tboyle10/medicaltranscriptions
Enron Emails https://www.cs.cmu.edu/~./enron/
https://www.kaggle.com/wcukierski/enron-email-dataset emails.csv


| Test::Differences - Test strings and data structures and show differences if not ok |
Test::Differences - Test strings and data structures and show differences if not ok
0.62
use Test; ## Or use Test::More use Test::Differences;
eq_or_diff $got, "a\nb\nc\n", "testing strings"; eq_or_diff \@got, [qw( a b c )], "testing arrays";
## Passing options: eq_or_diff $got, $expected, $name, { context => 300 }; ## options
## Using with DBI-like data structures
use DBI;
... open connection & prepare statement and @expected_... here...
eq_or_diff $sth->fetchall_arrayref, \@expected_arrays "testing DBI arrays"; eq_or_diff $sth->fetchall_hashref, \@expected_hashes, "testing DBI hashes";
## To force textual or data line numbering (text lines are numbered 1..): eq_or_diff_text ...; eq_or_diff_data ...;
This module exports three test functions and four diff-style functions:
When the code you're testing returns multiple lines, records or data
structures and they're just plain wrong, an equivalent to the Unix
diff
utility may be just what's needed. Here's output from an
example test script that checks two text documents and then two
(trivial) data structures:
t/99example....1..3 not ok 1 - differences in text # Failed test ((eval 2) at line 14) # +---+----------------+----------------+ # | Ln|Got |Expected | # +---+----------------+----------------+ # | 1|this is line 1 |this is line 1 | # * 2|this is line 2 |this is line b * # | 3|this is line 3 |this is line 3 | # +---+----------------+----------------+ not ok 2 - differences in whitespace # Failed test ((eval 2) at line 20) # +---+------------------+------------------+ # | Ln|Got |Expected | # +---+------------------+------------------+ # | 1| indented | indented | # * 2| indented |\tindented * # | 3| indented | indented | # +---+------------------+------------------+ not ok 3 # Failed test ((eval 2) at line 22) # +----+-------------------------------------+----------------------------+ # | Elt|Got |Expected | # +----+-------------------------------------+----------------------------+ # * 0|bless( [ |[ * # * 1| 'Move along, nothing to see here' | 'Dry, humorless message' * # * 2|], 'Test::Builder' ) |] * # +----+-------------------------------------+----------------------------+ # Looks like you failed 3 tests of 3.
eq_or_diff_...() compares two strings or (limited) data structures and either emits an ok indication or a side-by-side diff. Test::Differences is designed to be used with Test.pm and with Test::Simple, Test::More, and other Test::Builder based testing modules. As the SYNOPSIS shows, another testing module must be used as the basis for your test suite.
The options to eq_or_diff
give some fine-grained control over the output.
context
This allows you to control the amount of context shown:
eq_or_diff $got, $expected, $name, { context => 50000 };
will show you lots and lots of context. Normally, eq_or_diff()
uses
some heuristics to determine whether to show 3 lines of context (like
a normal unified diff) or 25 lines.
data_type
text
or data
. See eq_or_diff_text
and eq_or_diff_data
to
understand this. You can usually ignore this.
Sortkeys
If passed, whatever value is added is used as the argument for the Data::Dumper manpage Sortkeys option. See the the Data::Dumper manpage docs to understand how you can control the Sortkeys behavior.
filename_a
and filename_b
The column headers to use in the output. They default to 'Got' and 'Expected'.
For extremely long strings, a table diff can wrap on your screen and be hard to read. If you are comfortable with different diff formats, you can switch to a format more suitable for your data. These are the four formats supported by the the Text::Diff manpage module and are set with the following functions:
table_diff
(the default)
unified_diff
oldstyle_diff
context_diff
You can run the following to understand the different diff output styles:
use Test::More 'no_plan'; use Test::Differences;
my $long_string = join '' => 1..40;
TODO: { local $TODO = 'Testing diff styles';
# this is the default and does not need to explicitly set unless you need # to reset it back from another diff type table_diff; eq_or_diff $long_string, "-$long_string", 'table diff';
unified_diff; eq_or_diff $long_string, "-$long_string", 'unified diff';
context_diff; eq_or_diff $long_string, "-$long_string", 'context diff';
oldstyle_diff; eq_or_diff $long_string, "-$long_string", 'oldstyle diff'; }
Generally you'll find that the following test output is disappointing.
use Test::Differences;
my $want = { 'Traditional Chinese' => '中國' }; my $have = { 'Traditional Chinese' => '中国' };
eq_or_diff $have, $want, 'Unicode, baby';
The output looks like this:
# Failed test 'Unicode, baby' # at t/unicode.t line 12. # +----+----------------------------+----------------------------+ # | Elt|Got |Expected | # +----+----------------------------+----------------------------+ # | 0|'Traditional Chinese' |'Traditional Chinese' | # * 1|'\xe4\xb8\xad\xe5\x9b\xbd' |'\xe4\xb8\xad\xe5\x9c\x8b' * # +----+----------------------------+----------------------------+ # Looks like you failed 1 test of 1. Dubious, test returned 1 (wstat 256, 0x100)
This is generally not helpful and someone points out that you didn't declare your test program as being utf8, so you do that:
use Test::Differences; use utf8;
my $want = { 'Traditional Chinese' => '中國' }; my $have = { 'Traditional Chinese' => '中国' };
eq_or_diff $have, $want, 'Unicode, baby';
Here's what you get:
# Failed test 'Unicode, baby' # at t/unicode.t line 12. # +----+-----------------------+-----------------------+ # | Elt|Got |Expected | # +----+-----------------------+-----------------------+ # | 0|'Traditional Chinese' |'Traditional Chinese' | # * 1|'\x{4e2d}\x{56fd}' |'\x{4e2d}\x{570b}' * # +----+-----------------------+-----------------------+ # Looks like you failed 1 test of 1. Dubious, test returned 1 (wstat 256, 0x100) Failed 1/1 subtests
That's better, but still awful. However, if you have Text::Diff
0.40 or
higher installed, you can add this to your code:
BEGIN { $ENV{DIFF_OUTPUT_UNICODE} = 1 }
Make sure you do this before you load the Text::Diff manpage. Then this is the output:
# +----+-----------------------+-----------------------+ # | Elt|Got |Expected | # +----+-----------------------+-----------------------+ # | 0|'Traditional Chinese' |'Traditional Chinese' | # * 1|'中国' |'中國' * # +----+-----------------------+-----------------------+
There are several basic ways of deploying Test::Differences requiring more or less labor by you or your users.
Fallback to is_deeply
.
This is your best option if you want this module to be optional.
use Test::More; BEGIN { if (!eval q{ use Test::Differences; 1 }) { *eq_or_diff = \&is_deeply; } }
eval "use Test::Differences";
If you want to detect the presence of Test::Differences on the fly, something like the following code might do the trick for you:
use Test qw( !ok ); ## get all syms *except* ok
eval "use Test::Differences"; use Data::Dumper;
sub ok { goto &eq_or_diff if defined &eq_or_diff && @_ > 1; @_ = map ref $_ ? Dumper( @_ ) : $_, @_; goto Test::&ok; }
plan tests => 1;
ok "a", "b";
PREREQ_PM => { .... "Test::Differences" => 0, ... }
This method will let CPAN and CPANPLUS users download it automatically. It will discomfit those users who choose/have to download all packages manually.
t/lib/Test/Differences.pm, t/lib/Text/Diff.pm, ...
By placing Test::Differences and its prerequisites in the t/lib directory, you avoid forcing your users to download the Test::Differences manually if they aren't using CPAN or CPANPLUS.
If you put a use lib "t/lib";
in the top of each test suite before the
use Test::Differences;
, make test
should work well.
You might want to check once in a while for new Test::Differences releases if you do this.
Test
or Test::More
This module "mixes in" with Test.pm or any of the test libraries based on Test::Builder (Test::Simple, Test::More, etc). It does this by peeking to see whether Test.pm or Test/Builder.pm is in %INC, so if you are not using one of those, it will print a warning and play dumb by not emitting test numbers (or incrementing them). If you are using one of these, it should interoperate nicely.
Exports all 3 functions by default (and by design). Use
use Test::Differences ();
to suppress this behavior if you don't like the namespace pollution.
This module will not override functions like ok()
, is()
, is_deeply()
, etc. If
it did, then you could eval "use Test::Differences qw( is_deeply );"
to get
automatic upgrading to diffing behaviors without the sub my_ok
shown above.
Test::Differences intentionally does not provide this behavior because this
would mean that Test::Differences would need to emulate every popular test
module out there, which would require far more coding and maintenance that I'm
willing to do. Use the eval and my_ok deployment shown above if you want some
level of automation.
Perls before 5.6.0 don't support characters > 255 at all, and 5.6.0 seems broken. This means that you might get odd results using perl5.6.0 with unicode strings.
Data::Dumper
and older Perls.Relies on Data::Dumper (for now), which, prior to perl5.8, will not always
report hashes in the same order. $Data::Dumper::Sortkeys
is set to 1,
so on more recent versions of Data::Dumper, this should not occur. Check CPAN
to see if it's been peeled out of the main perl distribution and backported.
Reported by Ilya Martynov<EMAIL_ADDRESS>although the Sortkeys "future
perfect" workaround has been set in anticipation of a new Data::Dumper for a
while. Note that the two hashes should report the same here:
not ok 5 # Failed test (t/ctrl/05-home.t at line 51) # +----+------------------------+----+------------------------+ # | Elt|Got | Elt|Expected | # +----+------------------------+----+------------------------+ # | 0|{ | 0|{ | # | 1| 'password' => '', | 1| 'password' => '', | # * 2| 'method' => 'login', * | | # | 3| 'ctrl' => 'home', | 2| 'ctrl' => 'home', | # | | * 3| 'method' => 'login', * # | 4| 'email' => 'test' | 4| 'email' => 'test' | # | 5|} | 5|} | # +----+------------------------+----+------------------------+
Data::Dumper also overlooks the difference between
$a[0] = \$a[1]; $a[1] = \$a[0]; # $a[0] = \$a[1]
and
$x = \$y; $y = \$x; @a = ( $x, $y ); # $a[0] = \$y, not \$a[1]
The former involves two scalars, the latter 4: $x, $y, and @a[0,1]. This was carefully explained to me in words of two syllables or less by Yves Orton<EMAIL_ADDRESS>The plan to address this is to allow you to select Data::Denter or some other module of your choice as an option.
Barrie Slaymaker<EMAIL_ADDRESS>- original author
Curtis "Ovid" Poe<EMAIL_ADDRESS>David Cantrell<EMAIL_ADDRESS>Copyright 2001-2008 Barrie Slaymaker, All Rights Reserved.
You may use this software under the terms of the GNU public license, any version, or the Artistic license.
| Test::Differences - Test strings and data structures and show differences if not ok |


#1
About the Movie Crawler
The Movie Scrapper is a Web platform that enables you to search your favourite movies, review and watch traillers. The platform is designed to provide all your entertainment needs in one place with ease of access.
The Movie Scrapper is a Web platform that enables you to search your favourite movies, review and watch traillers. The platform is designed to provide all your entertainment needs in one place with ease of access.


2020.10.15(TH)~16 16(FRI)
@National musum of nairobi,adlife art center
Main Program
Lecture
Listen to the speakers from various counties about the message of sharing
Exhibition
Appreciate various creations applying MALOBI licences of artists.
Forum
This is a wider card with supporting text below as a natural lead.
Workshop
Try creating your own work using open source licence rather just watching at it
CC ignite
Get opportunities to network with MOLOBI


VeriMap is a tool for converting single-rail RTL netlists into a dual-rail circuits resistant to DPA attacks. Its main features are:
The latest release of the tool can be found on VeriMap homepage:
The compilation of VeriMap tool from source is performed by the following command:
$ make
This will compile a binary called verimap
. In order to start using
the tool put this binary into a directory, which is referenced from the
PATH
environment variable (e.g. /usr/local/bin/
).
This can be done by running the following command as root:
$ make install
If you already have an executable of the VeriMap tool, then just copy it
into a directory which is referenced from your PATH
environment
variable.
Changes in VeriMap version 1.2 comparing to version 1.1:
-f FULL_FILE_NAME
or
--full FULL_FILE_NAME
is added. It produces a file
FULL_FILE_NAME
which contains a resultant circuit netlist together
with all required dual-rail modules (both generated and pre-defined).
Thanks to Karthik Baddam for the idea and testing of this feature.
Changes in VeriMap version 1.1 comparing to version 1.0:
ToDo list:
The VeriMap design kit converts single-rail RTL netlists into dual-rail circuits which are resistant to Differential Power Analysis (DPA) attacks. VeriMap design kit successfully interfaces to the Cadence CAD tools. It takes as input a structural Verilog netlist file, created by Cadence Ambit (or another logic synthesis tool), and converts it into dual-rail netlist. The resulting netlist can then be processed by Cadence or other EDA tools. All Design For Testability (DFT) features incorporated at the logic synthesis stage are preserved.
The VeriMap design flow (see the figure) consists of the following parts:
|
The library of gate prototypes is a set of Verilog files containing three types of gates:
The definitions of all single-rail gates which are instantiated in the circuit under conversion have to be in the library. These definitions are used by VeriMap to determine which connections of the gate are inputs and which are outputs. The implementation of these gates is not important and can be skipped.
The converters between single-rail and dual-rail domains, go-controller and spacer-controller are also defined in this library. This gates cannot be produced automatically by the tool and must be created manually for each design technology.
The library can also contain implementations of some dual-rail gates. The predefined dual-rail gates are used when the automatic conversion of a single-rail gate into dual-rail is impossible or gives a poor result. Typical examples for such gates are multiplexers, flip-flops and latches.
The library of rules for gate transformation defines how to convert a single-rail gate into a dual-rail one. If a predefined dual-rail implementation of a gate is found in the library of gate prototypes, then the tool uses it. Otherwise a dual-rail implementation is built automatically using these rules. Each line of this library defines one rule. A rule consist of the following space-separated fields:
The negative gate optimisation usually improves the size and speed of a dual-rail circuit. However, for a negative gate with high output drive it is not true, because such a gate consists of a positive gate and a strong inverter attached to the output. A library of gate attributes, is useful in such a case. For each single-rail gate it helps to chose the optimal dual-rail gate between its negative-logic and positive-logic implementations. If this library is missing, then the negative-logic dual-rail implementation is preferred.
The library consists of two sections. The first section lists the names of attributes, which are associated with each library gate. The second section assigns the values of these attributes to the gates.
The main function of the tool is conversion of a single-rail RTL netlist into a dual-rail netlist of either of two architectures: self-timed and clocked. It is done in four stages. Firstly, a single-rail circuit is converted into positive logic dual-rail. Secondly, the positive dual-rail gates are replaced by negative dual-rail gates and the spacer polarity inverters are inserted. This is the negative gate optimisation [1]. Then, the completion signal is generated (asynchronous design only) [2]. Finally, a wrapper module connecting the dual-rail circuit to the single-rail environment is added (optional).
Using the standard dual-rail protocol with a single spacer has certain balancing problems due to the asymmetry between logic gates within a dual-rail gate. We addressed and solved these problems in [3] by using a new protocol with two spacers alternating in time leading to all gates switching within every clock cycle. The tool supports the alternating spacer protocol.
Apart from generating netlists, VeriMap tool reports statistics for the original and resultant circuits: estimated area of combinational logic and flip-flops, number of negative gates and transistors, number of wires.
The tool also generates a behavioural Verilog file assisting the power analysis of the original and resultant circuits. Being included into simulation testbench these Verilog counts the number of switching events in each wire of the circuits.
The detail list of VeriMap command line parameters and their meaning follows.
USAGE:
verimap [OPTIONS] [INPUT_FILE_NAMES]
FILE OPTIONS:
-o, --output OUTPUT_FILE_NAME netlist output file [STDOUT]
-f, --full FULL_FILE_NAME full netlist output file []
-i, --include INC_FILE_NAMES library input files [STDIN]
-l, --library LIB_FILE_NAME library output file []
-g, --generate GEN_FILE_NAME generated modules input-output file [STDOUT]
-r, --rules RULES_FILE_NAMES rules for gate transformation input files []
-p, --params PARAMS_FILE_NAMES parameters of modules input files []
-a, --assignments ASSIGNMENTS_FILE_NAMES assignments input files []
-cn, --completion-nets COMPLETION_FILE_NAMES completion nets input files []
*_FILE_NAMES is a coma separated list of files for reading
TRANSFORMATION OPTIONS:
-tl, --transformation-level[TL] transformation level (TL=[0],1,2,3)
0 = no circuit transformation, the netlist is re-formatted only
1 = calculate the optimisation possibilities only, the output circuit
is still single-rail
2 = convert the circuit into dual-rail
3 = build completion detection logic, add go input and done output
-cd, --completion-delay[CD] completion delay in gate number (CD=[0],1...)
-as, --alternating-spacer optimise for alternating spacer protocol
-srw,--single-rail-wrapper build a single-rail wrapper
OPTIMISATION OPTIONS:
-ol, --optimisation-level[OL] optimisation level (OL=[0],1,2)
0 = no optimisation (positive gates)
1 = optimisation for negative gates or for specified parameters given
by --optimisation-params option
2 = optimisation of spacer converters distribution
-op, --optimisation-params PARAM_NAMES optimise for parameters []
PARAM_NAMES is a coma separated list of parameter names which are
specified in the files provided by --params option
-gd, --gate-delay-param PARAM_NAME name of the cell delay parameter []
PARAM_NAME is parameter name which is specified in the files
provided by --params option
STRUCTURE OPTIONS:
-tm, --topmost-module MODULE_NAME name of the topmost module
-buf,--buffer buffer SPACER and DONE signals
-ra, --reset-active[RA] reset active level (RA=[0],1)
0 = active-0 reset, 1 = active-1 reset
-rst,--reset PORT_NAMES names of reset ports [*.rst]
-clk,--clock PORT_NAMES names of clock ports [*.clk]
-sp0,--spacer-0 PORT_NAMES spacer-0 ports [*.*]
-sp1,--spacer-1 PORT_NAMES spacer-1 ports []
PORT_NAMES is a comma-separated list of MODULE_NAME.PORT_NAME
MODULE_NAME.* = all ports of the MODULE_NAME module
*.PORT_NAME = port PORT_NAME of all modules
*.* = all ports of all modules
PORT_NAME = port PORT_NAME of the topmost module
STATISTICS OPTIONS:
-s, --statistics STAT_FILE_NAME statistics output file [STDOUT]
-sl, --statistics-level[SL] statistics output level (SL=[0],1,2,3)
0 = no statistics is collected
1 = statistics is collected for single-rail circuit only
2 = statistics is collected for dual-rail circuit only
3 = statistics is collected for both single- and dual-rail circuits
CONES OPTIONS:
-c, --cones CONES_FILE_NAME cones output file name [-]
-cl, --cones-level[CL] cones output level (CL=[0],1,2,3)
0 = table of cones intersection only
1 = output nets in each cone
2 = output nets and instances in each cone
3 = additional comments for cones layers
-cv, --cones-vertex ITEM_NAMES list of vertex items to build the cones
ITEM_NAMES is a comma-separated list of MODULE_NAME.ITEM_NAME
ITEM_NAME is either net or instance name
MODULE_NAME.* = all nets and instances of the MODULE_NAME module
*.ITEM_NAME = item ITEM_NAME of all modules
*.* = all nets and instances of all modules
ITEM_NAME = item ITEM_NAME of the topmost module
SWITCHING ACTIVITY OPTIONS:
-w, --wires WIRES_FILE_NAME wires switching output file [STDOUT]
-wl, --wires-level[WL] wires switching output level (WL=[0],1,2,3)
0 = no wires switching analysis
1 = wires switching is analysed for single-rail circuit only
2 = wires switching is analysed for dual-rail circuit only
3 = wires switching is analysed for both single- and dual-rail circuits
-wp, --wires-pattern PATTERN wires output pattern [always @(?) c=c+1;]
Question mark ? in the PATTERN is replaced by the wires full names
TIMING ANALYSIS OPTIONS:
-cmd CMD_FILE_NAME Pearl timing analysis command file
-gcf GCF_FILE_NAME GCF file for timing analysis
-pp, --path-possibility[N] consider top-N path possibilities (N=[1],2...)
INFORMATION OPTIONS:
-h, --help print this help only
-v, --version print version only


{% extends "base.html" %} {% load i18n %} {% block css %} {% endblock %} {% block title %}{{ title }}{% endblock %} {% block content_title %}
Don't worry! Just fill in your email and we'll help you rest your password.


Before Change
// where that initial trial was created, and that creation line
// info is helpful to keep around anyway.
reinit_msg = "A session already exists in the current context."
if ignore_reinit_error:
if not _session.is_tune_session:
logger.warning(reinit_msg)
return
else:
raise ValueError(reinit_msg)
_session = _TrackSession(**session_kwargs)
def shutdown():
After Change
def init(ignore_reinit_error=True, **session_kwargs):
_deprecation_warning(soft=False)
def shutdown():
_deprecation_warning(soft=False)


| eBay |
Shop by category |
Used but in good condition
shipping: FREE Economy Shipping
Delivery: Estimated on or before Tue. Nov. 28
Returns: 30 days money back, buyer pays return shipping, 20% restocking fee may apply
Guarantee: Get the item you ordered or get your money back. Covers your purchase price and original shipping.


Stephanie Young and Will Gordon met through Match.com. It was in the middle of March, 2011. They
started out slowly, conversations through match.com, emails, and finally text messages. They agreed
to meet on April 2nd at Java's Cafe on Gibbs St. Well, the two hit it
off immediately! They were there for three hours, prompting a humorous phone call from Steph's
sister, "Bethany? Is there a Bethany here??". Yes, the barista apparently misheard Kristi asking
for "Stephanie"; and yes, Kristi had actually called Java's to make sure Stephanie was still ok.
The date ended with a lovely walk around Greece mall, still one of their favorite pastimes.
In April, Will made a mistake. He was unsure of himself, and unsure of the direction a relationship
between him and Stephanie may go. This was their rocky start, and Will ended the relationship before
it had ever officially began. But thanks to a wonderfully timed pizza dinner,
stuffed crust from Pizza Hut with alfredo sauce, and a Like on Facebook on August 21st,
a course correction had begun. This led to some long Facebook messages, more email conversations,
and finally a text message asking if Stephanie would consider a second chance...she made Will
wait for 3 hours before giving him her reply, it was yes!
They officially started dating on September 4th, 2011 (does that sound
like a familiar date?). It's been a wonderful adventure ever since! Skydiving, their first foray
into Mexico, late nights falling asleep on her mom's couch, Thanksgiving with his grandparents,
homework and studying. After 2 and a half years of dating, Stephanie graduated from SUNY Brockport
college. Will had found a Groupon (an amazing source of a few of their vacations) for Lake Placid
in the Adirondacks. This was Will's graduation gift to Stephanie, a couple of nights away. It was
also going to be a little bit more...


The Shopkeeper
Gives Santiago a job in Tangiers after he has been robbed. Santiago takes the job at the crystal shop and learns much about the shopkeeper’s attitude toward life and the importance of dreaming. The shopkeeper, while generally afraid to take risks, is a very kind man and understands Santiago’s quest – sometimes more than Santiago himself. This is the case when the shopkeeper tells Santiago that he will not return to Spain, since it is not his fate.


Copyright (c) 1995 Eric Remy
The game is played on a 9x9 torus board (i.e., there is no edges).
|
I would include to the original rules, that a stalemate is a loss, since it may occur that both stones are trapped inside a mutual area, and if adjacent to each other, they may never be surrounded just by walls!
| An example If White play at d2, Black must move c2-c3, to avoid defeat. Cell c3 is a seki point, i.e., both players would loose if they placed a wall there. |
There is a similar game, called Entrapment designed by Rich Gowell, more complex and probably more stable. There are three stones, called Roamers, with more freedom of movement. Check the full rules. There is also a Zillion's ZRF to play Entrapment. Another similar variants are Alcazar, Blockade, Cul-de-Sac and Quoridor.


Notebooks
Story: Dorothea Bleek - Book BC151_A3_032
Dorothea Bleek - Book BC151_A3_032
Title
Dorothea Bleek - Book BC151_A3_032
Collection
Summary
Bushman genealogies, undated. Some brief descriptions and personal histories, such as where individuals worked, came from, who they married, how many children they had and so on. Information about different groups such as the 'Vaalpens'. Names of people according to huts they occupy (10 of them), also some numbers next to their names.
Comments
On the first page it reads '13 Leeuwen St. Cape Town'. A reference to type faces, and what looks to eb a phone number of 'Mr Bain Bushman Camp'. On the back page (upside down) it reads 'Theal vol II before 1795' with references to an index, plus a note about the 'van Riebeeck Society Vol. 15' and 2 names [?]. Some pages are blank and some have been scribbled in, probably by the same child as in the previous notebook.
Date
Undated
Categories
Story Pages
Not paginated


In this post I refer to retrospectives as a type of meeting inspired by the 12th agile principle “At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.”.
Many factors–specific to your context–can reduce the effectiveness of a retrospective and cause frustration and mistrust in the group. In this brief blog post I will describe how psychological safety, purpose, preparedness and collaboration can help make your retrospectives even more effective.
I want to highlight this is not a checklist. And depending on what system/subsystem your retrospective is working with you might need to switch between lens/approaches for complicated or complex domains. I’ll probably followup on that in a separate post.
This post is for retrospective facilitators and regular team members that want to take on that role. You don’t need to be a trained facilitator, scrum master or product manager to introduce changes and make your retrospective even more effective.
Psychological Safety
Amy Edmondson has done extensive research since the 90s on the subject–and published a book in 2018–The Fearless Organization–Norm Kerth talks about a “Create Safety” exercise in his seminal Project retrospectives book published in 1999.
 Let me start from the foundation. Your retrospective outcomes will always be subpar if your team or organization does not support psychological safety.
If people are punished when speaking up they will withhold information or play the blame game fostering a low energy retrospective. Improving psychological safety at the organizational level is outside the purpose of this post but there are strategies you can use to assess and improve psychological safety at the team level.
Assess the team psychological safety
Start by collecting data on the psychological safety level of the group. Try to have one-on-ones with team members before the retrospective and take notes about their feelings. Try to run an anonymous activity (like Explorer, Shopper, Vacationer, Prisoner or Elephant in the room) when you set the stage of your retrospective to anonymously collect the safety levels.
If the the psychological safety level is low–say a room full of Prisoners in ESVP–you should switch the focus of the retrospective to increase the safety level. Try to run an anonymous brainstorm on “what is one thing that would have to change to make you all not be prisoners?”. It’s possible that the outcome of the whole retrospective will be a team norm document to ensure people feel comfortable to speak up… and that’s great! If you decide to continue with the original retrospective plan–despite a room full of disengaged folks–remind the group they will have a chance at the end of retro to provide feedback to make the next one safer.
Establish a safe space with the Retrospective Prime Directive
There are a multitude of activities to set a safe stage for your retrospective, one is to read “The prime directive” by Norm Kerth:
“Regardless of what we discover, we understand and truly believe that everyone did the best job they could, given what they knew at the time, their skills and abilities, the resources available, and the situation at hand.”
For some groups printing the directive, reading it and asking for a verbal “yes I believe it”–or alternatively “I believe for the duration/sake of this retrospective”–is sufficient to set a safe positive stage. In more dis-engaged groups some will say yes just to move on… but they truly believe someone messed up… they truly believe it’s someone’s fault. At times their fault. What do you believe as the facilitator? If you–the retrospective facilitator–doubt the directive then it’s nonsensical to ask for a group agreement on it. You can read an article I wrote that dissects the prime directive and better understand its roots. There is also a retrospective activity to challenge the retrospective prime directive with the group so instead of just a verbal yes you’d have a conversation about it.
The prime directive is similar to bounded rationality and when embraced allows the group to shift from looking for a culprit to collaboratively looking at the context and generate insights.
The retrospective purpose
If people don’t know why they’re in a retrospective and what they will get out of it they will be disengaged.
Have you ever felt your retro is more like a happy hour then a reflection? Very often teams go through the motions and always run retrospective to “reflect on what could be improved from the last iteration”. For a 3 or 4 people team and smaller challenges that could work for a little while but I’ve seen that purpose lead to premature convergence. I’ve seen retros where people would discuss for the same amount of time items like “someone left a glass on the desk and there is now mold in it” and “we should refactor the reservation class based on the application’s bounded contexts”.
I think spending 2 minutes discussing an item is not reflection. The problem I see is that people only share information during retrospective so you end up with a lot of those smaller items. I call whack-a-mole retrospective when the team generates lots of mad/sad/glad items and try to fix all the sad with rushed action items. The outcomes I’ve seen are too many action items–carrying over from one iteration to the next–and people never getting to them.
There are at least a couple of options.
Agree on a real time agenda
Check if the group is ok to try a retrospective with a real time agenda (aka lean coffee). This helps because once the topics are listed the group can create clusters with a silent mapping activity, run a poll to prioritise what to talk about first. In this format the group decides if they want to keep talking about a topic of move on.
A critical piece–where the facilitator or an action item taker can help–is to acknowledge when a discussion ie. “we should refactor the reservation class based on the application’s bounded contexts” will not fit in the allocated timebox and agree to have a separate meeting dedicated to that topic. You must be clear about the purpose of the followup meeting. Is it to share information? Advance the thinking? Provide input? Make decisions? Improve communication? These goals are from Sam Kaner’s “Facilitator’s guide to participatory decision making” another great resource about having clear meeting is “Where the action is”.
Pick a retrospective topic
Another approach would be to focus the retrospective on a topic agreed with the team before the meeting–but that assume there was some preparation. When we focus the retrospective someone in the group might still want to talk about off-topic items. If people feel strongly about sharing something with the group let them do it. I think a better strategy is to run daily 10 minutes retrospectives–for teams of 4 or 5–so the team has space to share information during the week and focus on overarching issues during the iteration retrospective.
Preparedness
A retrospective is a meeting and to run a good meeting you need a clear purpose and some preparation. Your plan might not survive contact with the team–and their evershifting context–so it’s ok to improvise at that point. The facilitator should not go in and improvise activities by default or come in unprepared.
Going in to retrospective without a clue of what happened during the iteration should be an exception.
In small (5/6 people teams) I like to prevent that by taking one-on-one time with the group before retrospective to see what’s on their mind and prepare a retrospective plan that fits where they are at this time. For larger teams you can collect information with the help of co-facilitators.
I once was in a retrospective where the facilitator was trying to explain Jean Tabaka’s Sailboat activity while reading it on the phone. The group was pretty confused. When I pick up a new activity I write down a little script to explain the activity purpose and what the individuals are expected to do. If it involves drawing I practice it beforehand.
I think too often people focus on the retrospective activity rather than on the framework.
Know your retrospective framework instead of activities
A framework gives structure to your retrospective and a clear start and end. I base my retrospectives plans on Derby/Larsen’s 5 steps framework and I pick activities that fit the group’s journey. I’ll briefly describe the 5 steps and you can look up other options like ORID by The institute of cultural affairsor Adaptive Action by Human system dynamics.
- Set the stage purpose: the group understands the goal of the retrospective, the room has psychological safety, roles are assigned, team norms acknowledged
- Gather data purpose: ensures the group is on the same page about what happened about the topic we’re focused on or the timespawn we’re looking at. The outcome should be a snapshot of all perspectives about what happened and hopefully mutual understanding. If the group doesn’t reach mutual understanding I’d spend more time until you get there. Reading “Facilitator’s guide to participatory decision-making” can give strategies to bring a group to mutual understanding.
- Generate insights purpose: the group finds focus on a topic with affinity mapping, polling, prioritization to allow the team to go past the immediate solutioning and have a deeper conversation about no more than 1/2 topics. The outcome should be a set of ideas to formalise into an experiment for change.
- Decide what to do purpose: the group comes up with a specific, measurable and time bound experiment (aka action item) or acknowledging if the topic is too broad and the time left during retrospective is not sufficient to come up with a detailed plan. If so schedule a followup meeting with its purpose and its desired outcome.
- Close out purpose: the group acknowledges what was achieved in the meeting and is clear about next steps and responsibilities. Now is a good time to end on a high note with a round of appreciation. To speed up time in larger groups you can try having folks share appreciations via post-it notes or Jurgen Appelo’s Kudos cards
This is a great time to run a quick retro on your retrospective, I use a +ΔROTI. ROTI came from Esther Derby and it’s a Return Of Time Invested activity where you collect between 0 to 4 how well spent the time was. I ask the group to write the number on a post it note, and add a short sentence next to a Δ sign for the one improvement that would have made their ROTI go up by 1, and a short sentence next to a + for something they liked about today’s retro - 0: complete waste of time, I learned nothing - 1: mostly a waste of time but I learned one thing - 2: broke even, satisfactory retrospective - 3: better then an average, I learned quite a few things - 4: awesome, best retrospective of my life
If you’d like to learn more about the framework read Derby/Larsen’s book about “Agile Retrospectives”. If you want to learn the origin of the 5 steps framework you can listen to my interview with Diana Larsen on my Retrospective facilitation podcast here.
Collaboration
As the facilitator you’re not alone. If the retrospective is in a safe environment and there is a purpose and you are prepared the group should be there to help.
If you’re trying to juggle time keeping, note taking and action item collection while facilitating you can ask for volunteers for those tasks! That way there is a shared ownership of the process.
If you are the facilitator but also a team member–scrum master/product manager/lead/whatever–you have a hard job to keep your biases under control. I know I do as the team product manager–and previously principal engineer–I had very strong opinions on team topics we talked in retrospective I was facilitating. When I had something that I felt was critical for the group to hear I would say: “I am taking my facilitator hat off and as a PM I think…”. I usually try to keep it to a brief sentence to give more colour and then go back to my facilitator role unless more context is required. It might be good to have a backup facilitator if you feel your stakes are too high and you might not be an impartial facilitator.
You can ensure there is collaboration by having silent activities. For example instead of having an open discussion–where introverts and less loud people would be having a harder time contributing–use an activity like 1-2-4-all. Its purpose, having individuals brainstorm–ideas or topic–alone, then in pairs, then 4 then with the whole group.
Remember the facilitator skills:
- Encourage full participation
- Promote mutual understanding
- Foster inclusive solutions
- Cultivate shared responsibility
Conclusions
In order for a retrospective to become more effective your organization and team should foster psychological safety, as the facilitator try to prepare and define a clear retrospective purpose to ensure the group stays engaged and takes on targeted action items. Ultimately a retrospective requires collaboration and the facilitator (you?) is there to make sure the ride goes smoothly.
If you want to tackle organizational issues remember the team is part of a system. Look up Larsen/Shore’s agile fluency maturity model and Snowden’s Cynefin sense making framework for seeing issues and contexts from different lenses.
There are a lot of resources out there if you’re interested in the topic of reflection, retrospectives and facilitation. Here’s a few links:
- Derby/Larsen Agile retrospectives book
- Kua’s The Retrospective Handbook: A guide for agile teams
- Kaner’s Facilitator’s Guide to Participatory Decision-Making
- Retrium’s video guide to retrospectives by David Horowitz
- Retrospectives Podcast
What challenges do you face in your retrospectives? What are the part of this post that you won’t be able to use? Why?


Trek 2000 posts Q3 net profit following year-ago loss
by Leila LaiThumb drive maker Trek 2000 International on Monday posted a net profit of about US$4,000 for the third quarter ended Sept 30, compared to a net loss of S$1.96 million a year ago.
Revenue increased 64.6 per cent to US$7.6 million, driven by increases in market demand during the quarter. The group's Interactive Consumer Solutions (ICS) remained its key revenue generator, accounting for 96.8 per cent of overall revenue.
Earnings per share was 0.001 US cent compared to loss per share of 0.606 US cent a year ago.
For the nine months ended Sept 30, Trek 2000 registered a net profit of about US$149,000, compared to net loss of US$1.33 million in the corresponding period of the previous year.
Revenue declined 43.1 per cent to US$15.28 million, and earnings per share was 0.046 US cent compared to loss per share of 0.407 US cent a year ago.
Stay updated with
BT newsletters
Terms & conditions Sign up
No dividend was declared for the period under review.
Trek 2000 shares closed unchanged at seven Singapore cents before the results were announced on Monday.


Game Boy Advance (AGB-001)
In Japan, on March 21, 2001, Nintendo released a significant upgrade to the Game Boy line. The Game Boy Advance (also referred to as GBA) featured a 32 bit 16.8 MHz ARM.
In Japan, on March 21, 2001, Nintendo released a significant upgrade to the Game Boy line. The Game Boy Advance (also referred to as GBA) featured a 32 bit 16.8 MHz ARM.
There is a plethora of accessories for GBA, both official and unofficial and this is very common among any console made by Nintendo.
One of the most common and wanted modifications is the backlit mod using the screen from an AGS-101 (the Gameboy Advance SP). The plastic screen lens can be replaced with glass ones.
This mod allows you to change the speed of the GBA to one of four speeds including: normal, fast, ultra and slow-motion by simply simultaneously pressing three GBA buttons. GBAccelerator is useful for quickly bypassing text in games, speeding up games when they experience ‘slowdown’, for slowing down the action in tough games and for custom homemade games made to use the faster processing power that GBAccelerator provides. Chiptune producers will be able to create new, crazy sounds since the audio changes pitch as the speed changes.
GBAmp is a little but powerful amplifier module. GBAmp is a "Hi-Fi" grade Class-D amplifier which is more power efficient than Game Boy internal amplifier. This also can help your batteries last longer. Installation method can be found here.
A zero-lag, 720p HDMI kit for the Game Boy Advance, link here.
to add...
to add...
Flashcarts


Component: AMReceiverC
generic configuration AMReceiverC(am_id_t amId)
The virtualized AM reception abstraction.
Author:
Philip Levis
Date:
Jan 16 2006
See:
TEP 116: Packet Protocols
Provides
interface
AMPacket
interface
Packet
interface
Receive
Wiring


This application allows you to find potential memory pointers for games/processes
by providing memory dumps to aid cheat code/mod tool creation.
Most, if not all systems (e.g.
consoles and PCs) should be supported.
Click here to watch a tutorial on this application
and here to see an example Nintendo Wii U cheat code
being created.
Copyright © 2016 - 2021 BullyWiiPlaza Productions
License
Note
Since this tool took tons of research, optimization, testing and debugging over years
and regardless has been made available free of charge to benefit the game modding community,
your gratitude in form of a donation would be greatly appreciated:
PayPal
Thank you :)


Spain's Bautista Agut out of Davis Cup after father's death
MADRID, Nov 22 ― Spain's Roberto Bautista Agut has withdrawn from the Davis Cup Finals after the death of his father yesterday.
Bautista Agut played in Spain's victories over Russia and Croatia but left the team and returned to Castellon after the health of his father Joaquin deteriorated.
Bautista Agut, who reached this year's Wimbledon semi-finals, lost his mother suddenly in 2018.
Hosts Spain play Argentina today at Madrid's La Caja Magica for a place in the semi-finals.
Feliciano Lopez, Marcel Granollers and Pablo Carreno Busta are Spain's other options to share the singles load with world number one Rafael Nadal. ― Reuters