Note
Looking for Concurrency: looking for positive models?Prothon looks quite interesting.
Prothon uses whitespace for continuations, so if a line is indented from the previous line it is considered a continuation of that line. I have a really hard time keeping lines under 80 characters in width, and \ and () always break up my coding -- the first is ugly, and the second requires me to back up to the beginning of the line once I realize I'm going over 80 characters.
This is purely syntactic, Python could also do this.
This is really at the heart of Prothon. This is actually my plan for OO in PyLogo (except it's called TELL there). When you use with var:, var becomes the "self" object (though Prothon doesn't use the word "self").
This kind of scares me, though. My experience with DTML shows that this is a horrible feature. Though, that said, I'm not sure if with is quite as dangerous as dtml-with -- so long as it only applies locally it's not too bad. The issue would be something like:
with File: def .writeAll(*objs): for ob in objs: .write(CustString(ob)) def CustString(ob): if .filename.endswith('.txt'): ob = Str(obj) else: ob = Str(obj).encode('UTF-8')
I don't know, I'm kind of contriving that example. But the question being, do you "inherit" the . (self) according to call order? Or only statically? Eh, they probably do the right (static only) thing here.
Or, more specifically, something like:
def Point.move(xofs, yofs): ...
In this case, adding a method move to Point. I like this, it's very natural feeling. It is used to more effect in Prothon than it would be in normal Python.
In Prothon, locals start with lower-case letters or the underscore, and globals are capitalized. This is okay. I still like lower-case functions, but I can live with upper-case functions.
I do not like all the prefixes they come up with. I think this is clearly a case of starting with one or two prefixes, then it spiraling out of control. Here's the prefixes:
| Prefix | Meaning |
|---|---|
| . | .x is like self.x, kind of. Problem: . can't be pronounced, and it's really small. I still like self, though I can understand taking it out of method signatures. I think they should make self a keyword. |
| ^ | Like "super", though the exact equivalent in Python is terribly confusing (the super() function). I'm used to it from Smalltalk, and like the brevity compared to Python's standard mechanism. A super keyword would still be better (to go with a self keyword). |
| & | This is a closure variable -- a variable that is defined in the parent scope. Anyone who has tried Scheme-style closures in Python has probably known the suffering of trying to figure out how scopes work. This makes it very explicit, which actually makes it usable. I also imagine it makes it easier to implement, since you actually know which variables need to be kept with the closure. Horrible punctuation, but a good idea. |
| @ | Dynamic local variables. There's no equivalent in Python -- you'd have to open up the current frame object and look in parent scopes. While it's expedient, I think it's also a very bad idea to provide this. That kind of mucking about with parent scopes is just asking for problems. I guess it could be used to macro-like effect in some ways. |
__init__ allows for more playing around than in Python -- you can return an object besides self and effect the result of the constructor. Of course, you've already constructed the object anyway, so maybe __new__ really is called for, if you actually want to avoid creating an object. (If you had to call ^__init__ to construct the object, then it would be more general)
In the list of little tweaks, they also allow identifiers to contain !, with the usual meaning (indicating the method mutates the object). I always like that punctuation, so I like that it's in there. It's much more useful than Python's convention of returning None -- I can tell statically that a method name contains !, but I can't do the same for returning None, and returning None is annoying. Prothon also returns self by default, instead of returning None (there's some conflicting information on this, so they might not be doing this). I like ? in identifiers as well, but Prothon doesn't add that.
There also seems to be a tendency to global methods, like obj.chr() instead of str(obj). I'm not entirely clear about this -- I think it falls out of the way builtins are defined. I generally prefer Python's style with magic methods, purely from an aesthetic point of view, though I can understand why some people would prefer using methods for everything.
There's also some changes in generators, but I haven't used generators enough to have an opinion on the subject. I think the change is fairly significant, from a stylistic/usage point of view.
It's an interesting effort. There are some small aesthetic/syntactic changes, some of which I like and some of which I don't. Then there's the prototypes... which are something else entirely.
I actually wonder to what degree prototypes could be implemented in Python with metaclasses. While some of the syntax would currently be crufy with Python (e.g., you'd have to create a function, then assign the function to an object), that's kind of a separate issue. The basic object model in Python feels like it should be replaceable, especially since we already have both new and old style classes. I think it's still a bit hard to think about these with the syntax getting in the way or otherwise being distracting, but feel like the potential is in there somewhere.
If it could be hacked onto Python instead of developed entirely separately from Python, it could make Prothon much more interesting from the perspective of practical programming. Ultimately it would probably have to be like Stackless -- a patch against Python implementing some necessary changes to syntax. But that's a more viable development effort, and one that's more likely to percolate ideas into the main Python interpreter.
I checked out your comments thinking you'd certainly have a reaction to the elimination of the GIL. *That* is what caught my attention regarding Prothon.
I seem to remember you saying you don't think the GIL is much of a design flaw. I do. I'm very interested to see if this really might be the end of the GIL. Preferably in Python. I see the GIL as the #1 weakness in Python. For me, at least, with access to machines with 16 processors.# John Mudd
The GIL needs to stay as-is if Python is going to be reasonably programmable at the C API. It would also make Python a lot slower, and it would break just about every extension... neither of which it needs. A GIL-free Python is going to have to wait until something smarter comes along, like PyPy, which could just automatically parallelize your code if it makes sense to do so.
If you have 16 processors, use 16 processes. You'll do fine. With shared memory on a decent kernel, the only real latency you'll see is going to be your fault ;)
You're probably thinking of this post:
http://blog.colorstudy.com/ianb/weblog/2003/10/31.html#P24
Wherein I agree with Bob, and think the GIL isn't so bad.# Ian Bicking
PyPy already sounded cool. If it can eliminate the GIL or find anothre route to SMP performance then it's just that much better. Cool.
I do read often that the GIL must stay. But what about Java? No GIL there. I'v even converted Python to Jython, switched to Java threads and, wow, it works great. Of course, only on a JVM. But doesn't that show the way for CPython developers? (If Sun can do it...) And I guess Prothon might also show the way if it suceeds.
Until the GIL is gone from CPython I feel like Java is still ahead, which is depressing. It's hard for me to honestly persuade Java programers to try CPython so long as there's a GIL.# John Mudd
Have you ever compared Java's performance for Python-style data structures like lists (Vectors) and dictionaries (Hashtables)? It's just a guess, but I think you'll find that Python's structures beat the snot out of Java's, because Python's don't require synchronized methods. They're implicitly synchronized by the GIL. Whereas Java objects need to have locks around each method call.
For Java, this is acceptable *only* because vectors and hashtables aren't on the critical path for performance. Java object fields are accessed using fixed offsets. In Python, those structures are used for *everything* (including all attribute lookups and use of globals), so adding item-specific synchronization kills Python performance dead dead dead. There was a guy who actually made a version of Python without the GIL, and it was "only" 50% SLOWER than Python with the GIL.
# Phillip J. Eby
>I actually wonder to what degree prototypes couldcould you describe this more?
that java needs to synchronize every method call?
i've done some java programming (2years), and when i wanted to synchronize, i used synchronize, and when i did not want it, i did not use it.
that's all.
there is absolutely NO need to put synchronize around every method call imho.
# Gabor Farkas
>be implemented in Python with metaclasses.
Prototypes could certainly be implemented in current Python (I think that Lulu Lotus Eater IBM guy posted something on the Slashdot story about it), but it's a bit like asking to implement OOP in C.
See the also comp.lang.python for more debate.# Michael
On the subject of the GIL again: I think it would be far, far more interesting to make multiple-process Python programs easier to write -- to make interprocess communication seemless, and just generally to establish robust (and easy to use!) patterns for that kind of programming. The benefits would far excede the benefits of mere SMP threading performance. But even right now, I imagine it's way easier to write a multi-process Python program than a threaded Java program.
On prototypes, Hans Nowak has played around with systems implemented in Python, in posts like:
http://zephyrfalcon.org/weblog/arch_d7_2003_09_13.html#e343
I think Prothon takes it a bit further... but maybe not that much further once you look past the syntax.# Ian Bicking
Personally, I think that pre-emptive threads with the same object space is THE WRONG PARADIGM ANYWAY. It makes for impossible to predict and debug code, thread locks suck, doesn't cooperate with event systems like GUIs, etc. I'm willing to bet that much higher performance and reliability can be attained with something else that is actually easier to code (something else that doesn't exist for a Python-like-language yet). Processes (pre-emptive switching between separate execution contexts that can be explicitly parallelized to multiple CPUs) and stackless-like tasklets (task switching in a single execution context) are the best we can currently do in Python, live with it, it's not going to change.
Everything I keep reading and hearing about repeats the theme that threads are an accident that came from people trying to "perfect" processes and thus making them too slow. Threading is way too hard and there are no indications that it will continue to be anything but a dead end. Other forms of concurrency, especially ones that are more OO and that remove problems like deadlock and race conditions, are much more preferable.
Re: "Threading is way too hard"
For me threads are much simpler to use than forking processes and, for example, using xmlrpclib for inter-thread communication. I've done both, and God bless xmlrpclib, but processes are still tedious compared to simple, almost magical, threads.
Did you mean hard to use or hard to build into the language? Even CPython already gives access to real native threads. I have to keep reminding myself of that. It's just the GIL design that kills (not just 2X, more like 10X) potential performance. I have a Jython thread demo that run circles around CPython. Of course, only with multiple CPUs.
Re: "Other forms of concurrency... are much more preferable."
I admit I'm kinda stuck on threads. What else should I try?# John Mudd
As far as I know, concurrency is far from being a solved problem in computer science.
Stackless offers some different -- or at least, unfamiliar to me -- models. Which reminds me: must beat up Christian until he agrees to talk about them at europython :-)
On another note ... I haven't seen anyone upset at the potential that alternative Python implementations like Prothon have to fragment the Python user base. People are already talking about the profileration of web frameworks in Python ... what about when the language itself has 3-4 different implementations? Jython has a good reason for existence, but much of Prothon's design seems to be related to personal preference, not actual improvements.# Brandon Corfman
Prothon IS NOT PYTHON. Did you read the post?
> I think it would be far, far more interesting to make
> multiple-process Python programs easier to write
The problem is that under Windows, a process-switch takes a lot more times than a thread-switch.
So replacing a multi threaded prog by several processes communicating with some protocols is not as much a solution as it can be with, say, Linux (I don't know it, but I have been told that under Linux process ~ thread under Windows).
That's not to say it can't be done, but there are possibly more cases under windows where you have no other choice than using threads whereas you have the option under Linux to use a multi processes solution.
I wish processes were not so heavy with Windows: I made a lot of multi-threading programming until now, I know the problems it involves and how it can be frustrating to debug such programs !# popov
Prothon is close enough to Python (notice the spelling here) to consider it an alternative implementation in my mind. Except for the 64-bit/threading issues which are a minor issue to most (wasn't this supposed to be a _simpler_ language??), the "big changes" of tabs/spaces, removal of self, and removal of classes/metaclasses is just noise. Why introduce another implementation that solves no apparent issues except syntax?# Brandon Corfman
Yes, of course, it's exactly the same except it has a totally different idea of scope, a completely different object system, and a fresh implementation intended for tomorrow's computers and very large problem sets. Come on :)
]] Dynamic local variables. There's no equivalent in Python -- you'd have to open up the current frame object and look in parent scopes. While it's expedient, I think it's also a very bad idea to provide this. That kind of mucking about with parent scopes is just asking for problems. I guess it could be used to macro-like effect in some ways. [[
Actually aren't all local variables in Python dynamic?
def func():
print x, y
x = 1
y = 2
func()
I agree that this is a really bad idea...
No. Those are globals!
>>> def func():
... print x,y
...
>>> import dis
>>> dis.dis(func.func_code)
2 0 LOAD_GLOBAL 0 (x)
3 PRINT_ITEM
4 LOAD_GLOBAL 1 (y)
7 PRINT_ITEM
8 PRINT_NEWLINE
9 LOAD_CONST 0 (None)
12 RETURN_VALUE
I can almost guarantee that the process switching overhead in Windows is far less than the overhead that you get with the GIL... because guess what, two chunks of python code can NEVER EVER RUN AT THE SAME TIME with Python threads! :) It's only carefully written C code that can explicitly allow ONE python thread to run concurrently while it's doing something way outside of the Python domain.
That said, I don't use Windows anymore, so I can't do a benchmark, but I think you are blowing the win32 process switching overhead out of proportion.
Ah, thanks for clearing that up, Bob.
To the person who was complaining about process-switch... are you sure you're not talking about the slowness of creating processes vs. threads on Windows? (By "switch" I assume everyone is talking about context switching?)


Angel List - Funding start-ups in technology and healthcare
Explore this data visualization to discover the companies being funded by accredited angel investors.
-
Switch between the different tabs to filter data by different categories.
-
Mouse-over the bubbles to learn more about each company.


<content> |
The HTML <content> element is used inside of Shadow DOM as an insertion point. It is not intended to be used in ordinary HTML. It is used with Web Components. It has now been replaced by the <slot> element. |
<element> |
The HTML <element> element is used to define new custom DOM elements. |
<shadow> |
The HTML <shadow> element is used as a shadow DOM insertion point. You might use it if you have created multiple shadow roots under a shadow host. It is not useful in ordinary HTML. It is used with Web Components. |
<template> |
The HTML template element <template> is a mechanism for holding client-side content that is not to be rendered when a page is loaded but may subsequently be instantiated during runtime using JavaScript. |


Toggle navigation
Bit6 Demo
About
Logout
Loading...
Welcome!
Try Bit6 awesomeness right in your browser.
Login
Sign Up
John is calling...
Do you dare to answer this call?
Video
Audio
Reject
Chats
New
Direct Chat
New Group
Audio
Video
Front Camera
Back Camera
Media mode: P2P
Share screen
Group details
Delete messages
Video Call
Record
Hangup
×
Group info
General
Members
Permissions
General
ID:
Me:
Meta
Members
Show JSON
User
Role
Presence
Action
Invite
Permissions


Bananium Labs was formed in November 2017 after numerous students consolidated and decided to work cooperatively.
We decided to create an organization in which we could organize our various
software projects, Git repositories, and hackathon submissions into one place. Never again would
we have to have the hour-long debate surrounding whose account to associate our code to. What started
as a small group of three developers grew quickly, as we began to look for more members to attend
hackathons and contribute to our projects. So far, we have attended
7 hackathons (our projects are showcased below). We're also interested in game development-
our game projects are organized within
Two Terabyte Studios.
Bananium Labs is based at Monta Vista High School, in Cupertino, California. If you are a web developer
at Monta Vista, and are familiar with HTML, CSS, JavaScript, TypeScript, AngularJS/2, PHP, Ionic/NativeScript,
ReactJS, NodeJS, Ruby, Python, Polymer, and/or another similar language or framework, we want to
meet with you!
Bananium Labs is in the process of acquiring 501c3 status after a focus shift to better fit our present purpose of
developing new and exciting projects and inspiring others to pursue STEM education.
Email us to let us know if you're interested in membership or collaboration.
Launch Hacks I
closeLaunch Hacks is a 24 hour, 200-participant hackathon hosted by Monta Vista High School students. Our goal is to bring high school students in the Bay Area together to convert ideas into reality. In addition to helping students improve their design and development skills, we also provide support to help students improve business and presentation skills- not just to pitch a successful project, but also to inspire the next generation of inventors, entrepreneurs, and leaders. Food, workshops, prizes, and swag will be provided to all participants for free!
LaunchHacks I is proudly hosted by BananiumLabs.
FlyMail
closeWinner - Best Internet Of Things
Today's world is full of complications and information that is easily lost in other information found in other information. With the hassles of letters, taxes, bills, and paychecks all coming in the same place, we decided to make it a bit more organized. This is why we made Fly Mail, an physical electronic mail box that sorts and stores your mail into piles and the cloud respectively, allowing organization and an effortless life style at the forefront of your day.
Hardware with Arduino, relay from digikey (since we dont have a H bridge), Dragonboard for running vision, and a low res usb camera. Most important of all, a Nike 'project' box.
Contributors: Eric Qian, Muaaz Wahid, Omar Hossain
AtomBlast
closeAtomBlast is an online multiplayer arena game set at the atomic level. You control your own atom and fight with your team against other players to gain the most points. Collect atoms to craft into compounds with the click of a button- each compound has unique qualities that can help you attack, defend, and gain buffs! Strategically minded maps, weaponry, team play, and game modes only add to the fuel!!
Made with Pixi.js renderer, Node.js backend, Socket.io networking. Written in JavaScript
Contributors: Ben Cuan, Eric Qian, Akash Basu, Adarsh Iyer, Jeffery Yang, Kevin Chu, Muaaz Wahid
CarrotCane
closeWinner - 1st Place
CarrotCane is a DIY cane attachment to assist the blind and visually impaired. Its main features are derived from an Arduino sensor suite which gives audible alert signals as well as GPS tracking capabilities to users.
Hardware with Arduino, Server with Node.js, Mobile App with Ionic, Web Console with Socket.io.
Contributors: Ben Cuan, Eric Qian, Tai Nguyen
Ditto
closeA beginner's first programming language to aid in the transition between visual programming and higher level text-based programming. Compiles into JavaScript, which can be used to create basic web applications.
Written and compiled using JavaScript.
Contributors: Adarsh Iyer, Alex Waitz, Alexey Kolechkin, Vikram Peddinti
AudiSea
close
Winner - 4th-6th Place
An audio visualizer that allows you to see your music as it plays in an ocean setting...in VR!
Written using AFrame.
Contributors: Ben Cuan, Eric Qian, Alexey Kolechkin, Alex Waitz
Honeydue
closeWinner - Best .tech Website!
Responsive cross-platform app which intelligently generates schedules to help you stay focused on your homework!
Written using Angular2 + Nebular.
Contributors: Ben Cuan, Eric Qian, Viraj Shitole, Omar Hossain
HotSwap
closeWinner - 4th Place
The perfect platform to encourage collaboration and learning in a safe environment by facilitating book and supply exchanges at school.
Contributors: Ben Cuan, Eric Qian, Alexey Kolechkin, Vikram Peddinti
Aspicio
closeInstead of walking with a cane or some other aid, visually impaired people walk around with their phone with Aspicio running. The lightweight app built with angular takes constant pictures and connects to a python based server to analyze the photos. With the use of powerful GPU's in the cloud, the image is processed almost instantly and sent back to the phone which gives vibration and sound feedback if an obstacle is there.
Contributors: Ben Cuan, Eric Qian, Viraj Shitole, Vikram Peddinti
Cupertino Intellimaps
closeMobile app for reporting community issues such as crime and road repair. Submitted reports are saved to our database and can be read from the admin console where they can be resolved.
Contributors: Ben Cuan, Eric Qian, Vikram Peddinti, Matthew Park
BamBoard
closeAn art collaboration platform aimed to create art that involve multiple people and personalities.
Contributors: Omar Hossain, Akash Basu, Vikram Peddinti
Tipnote
closeTipnote is an app in which a student, teacher, or any user can freely exercise their creative processes, manage tasks, use version control, and summarize files with portfolios.
Examples: projects, documenting learning approaches, git repositories, development cycles, article summarization, etc.
Contributors: Akash Basu


|
|||||||||
| PREV NEXT | FRAMES NO FRAMES |
Solo.waitForCondition(Condition, int)
.true
if the
searched Button is found a given number of times.
true
if the
searched Button is found a given number of times.
true
if at least one item
is found with the expected text.
true
if at least one item
is found with the expected text.
true
if the searched text is found a given
number of times.
true
if the searched text is found a given
number of times.
true
if the searched text is found a given
number of times.
true
if at least one ToggleButton
is found.
true
if the
searched ToggleButton is found a given number of times.
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES |


Class for handling Cloud Files Authentication, call it's authenticate() method to obtain authorized service urls and an authentication token.
Class for establishing connections to the Cloud Files storage system.
Create a new remote storage Object
Helper function to create "path" elements for a given Object name


Keep track of dates in terms of months. Model dates as at close of business. Perform date arithmetic in units of "months" and "years" (multiples of months). Allow "infinite" dates to model "ultimate" time spans.
| Version: | <IP_ADDRESS> |
| Depends: | utils, methods, R (≥ 3.0.0) |
| Suggests: | zoo |
| Published: | 2013-07-21 |
| Author: | Dan Murphy |
| Maintainer: | Dan Murphy <chiefmurphy at gmail.com> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | http://www.r-project.org, http://code.google.com/p/mondate/ |
| NeedsCompilation: | no |
| Materials: | NEWS |
| In views: | TimeSeries |
| CRAN checks: | mondate results |
| Reference manual: | mondate.pdf |
| Package source: | mondate_<IP_ADDRESS>.tar.gz |
| Windows binaries: | r-devel: mondate_<IP_ADDRESS>.zip, r-release: mondate_<IP_ADDRESS>.zip, r-oldrel: mondate_<IP_ADDRESS>.zip |
| OS X binaries: | r-release: mondate_<IP_ADDRESS>.tgz, r-oldrel: mondate_<IP_ADDRESS>.tgz |
| Old sources: | mondate archive |
| Reverse suggests: | MRMR, raw, zoo |
Please use the canonical form https://CRAN.R-project.org/package=mondate to link to this page.


When I first put user accounts into the wiki, I did it the simplest way I could -- I pickled each User object to disk. Then a little later I refactored the layout, so all the modules changed locations -- and the pickles broke. I could have tried to fix them -- maybe editing them by hand (there weren't many), or putting files back in place, unpickling, then reconstructing them.
There weren't many accounts, so I just blew them away and stored user information in flat files (rfc822 style). Now I don't have to worry about this in the future, as the data is stored very transparently, and forward and backward compatibility can be managed on an as-needed basis.
My conclusion? Never keep anything you care about in a pickle, at any point you should be able to blow it away. If you can't, then pickle isn't right for you.
A corollary: do keep things in explicitly formatted text files, maybe XML (or even YAML), maybe simpler than that (like RFC822, i.e., mail-header style).
The reason I like an RDBMS is because it's almost as good as a flat text file, but with a bunch of extra features. Any good RDBMS can be serialized to a sequence of SQL statements, again increasing transparency. Mapping between Python and the RDBMS is explicit, which is good -- because the data will probably live longer than the code, so the code should adapt to the data, not the other way around. The formality of an RDBMS -- type restrictions and all -- again safeguards the data.
And perhaps a corollary: I'm not a big fan of using lots of stored procedures and other related features (many uses of triggers and views, for instance). I'm trying to protect the data from the code, and putting code in the database compromises that. Though I'm still trying to figure out what the right balance is, where data integrity should (or can) be ensured, what logic is intrinsic to the database.
You can dissect pickles for which you do not have the original source by subclassing Unpickler and overriding stuff like find_class.. It's not as painful as you make it sound.
rfc822, xml, etc. aren't very good at object graphs and memoizing :)
Perhaps you should take a look at http://xmlobject.base-art.net/ :)
Bye Bye
xmlobject is GPL. I wouldn't even give it a second glance. GPL is ok for applications, but way more trouble than it's worth for libraries.
Ian: "My conclusion? Never keep anything you care about in a pickle, at any point you should be able to blow it away. If you can't, then pickle isn't right for you."
Hmm. By extension, would you say the same applies to
keeping things you care about in the ZODB?
# Don Wong
related:
http://www.livejournal.com/users/glyf/6877.html
(my own guideline is that "your application's data format is part of the design, and if you never look at it, how can you know if it's any good". fwiw, I only use pickle when I need to cache stuff on disk, and even then I tend to stick to simple data types).
Bob: I'm quite new to these issues. I read http://www.gnu.org/licenses/why-not-lgpl.html and then chose the GPL. Could you explain the reasons why XMLObject should not be under GPL ?
Of course I'm *open* to discussion :-)
Is XMLObject supposed to be a political statement or free software? If it's a political statement, GPL is the way to go. Otherwise, choose a less restrictive license and people may actually use your software. The Linux kernel, GCC, and readline are flukes.. the most popular open source software is more liberally licensed (Python, Apache, etc.). So what if Microsoft uses your source code? Are you more concerned about sharing, or forcing other people to share with you?
Dumbing down the database doesn't protect it from anything but a lack of willingness to learn SQL.
The smart/dumb database argument is a perennial one amongst a certain type of OO purist prevalent in Java circles. I tend to the "smart database" end of this debate - This is my take on this argument:
Typically the "intrinsic" logic in the database concerns enforcing cardinality and conditional relationships (child record can only exist when the parent record has values a, b or c in field X). Think in terms of data-related validations that an application would otherwise have to check for (e.g. this date must be after that one). Declarative constraints can get you quite a long way; use triggers as it makes sense to do so for more complex validations. This is much a matter of taste as anything else, but there are things that triggers do really well.
The smarter the database the more that applications can assume about the data (and therefore they are simpler). Note the plural "applications" here - this is never a 1:1 relationship if the database contains important information. Moving intelligence to the database allows it to be reused between applications.
The python language and DB-API provide fairly powerful features for manipulating data as data. Python's type system fits nicely with database work through pythonic DB-API interfaces [For a quickie PDF report generator CGI try putting a lightweight generator (to do rollups) over a large sorted query result and pretty-print the output to LaTeX].
One of the arguments in favour of "model object" architectures is that business logic all lives in the same place (ABC costing models in Java anyone?). There is some merit in this argument but it needs to be implemented in a fairly purist way to achieve this goal. Doing this tends to bring in a lot of infrastructural baggage like CMP entity beans to the architecture of a business application. Hard to tune, hard to troubleshoot, "magic" stuff happening behind the scenes that nobody understands.
I'm not convinced that a complex object mapping layer (try implementing one that supports labelled M:M relationships, transactional units of work and optimistic concurrency) adds much value to Python. Database work in C++ or java is clumsy due to the relatively low level nature of the interfaces and impedance mismatch of the type systems. Python lets you manipulate data with relatively high level constructs so there is not so much saved effort as there is with Java. IIRC cx_Oracle 4.0 now supports XA transactions.
More importantly, placing all your validation in the middle-tier locks you into J2EE, .NET, COBOL or whatever for your application architecture happens to be today. Placing intelligence into the database makes some steps to decoupling the applications from the data. See http://www.microfocus.com for a look into the market for tools to maintain legacy COBOL applications.
Appropriate use of not-null fields, default values, referential and check constraints goes quite a long way to keeping the data relatively clean. Consider using database triggers to encapsulate more complex validation on important tables. Always use triggers or materialised views (where available) if you need to denormalise data in a transactional application. This way the de-normalisation is inherent in the schema and the database never forgets it.
Back in 4GL days it was common to have insert, update and delete sprocs for every table in a database; data level validation and business rules were implemented in these procedures.  More than one way to skin that particular cat. I've seen databases in this style moved from Oracle forms to J2EE applications with little modification.
There's a whole essay in this particular topic (and many have been written) which I don't have time to write at the moment. Take this as food for thought from someone who's designed a big database or two in their day.# Nigel Campbell
Re: GPL -- I think it's unfair to say GCC or Linux were a fluke. They've both received significant contributions because of the GPL -- like Objective C support, or any number of features in Linux -- and I expect that to continue. OTOH, I don't think the GPL is right for XMLObject. The GPL is difficult to use in a conglomeration of software, especially when the GPLed portion is small, and that's going to be the case with any library.
If I had a really awesome library, or some compelling reason to choose the GPL (e.g., business reasons, or I in turn used a GPLed library), then I might choose GPL for a library. I think there are very good arguments to be made for the GPL. However, in most cases it's not really right for a library. OTOH, I think it's perfectly fine for applications, and would be my license of choice in those cases.# Ian Bicking
"Never keep anything you care about in a pickle". Well, one way around this is to decouple the storage from the representation. When you want to store something, zap up a more-or-less generic object from a MyStorage module and save the data on its attributes, then pickle *that*. To reinstantiate, make your actual data model objects consume an unpickled MyStorage object. Sure, it's an extra level of indirection, but it isolates you. I see that as somewhat more fun than messing around doing the sort of string-handling that one needs to with text files... and as soon as you have text files you *know* someone's going to start editing them, so you have to have a resilient parser... yada yada yada. :)
ben_
# Ben Last
YAML is the way to go, better if it's possible to use it as the pickling backend for a full blown object prevalence layer (dunno if pypersist allows this, but it should)
Just my 2cents# gab
This got me out of a similar pickle.
All my classes were in one module though...
#-------------------------------------------------------------------------------
# This is a fix.
# The module name is saved in the pickle so if you move your module hiearchy
# around you cant unpickle. This replaces the lookup function so that a load
# will ignore the module name.
#-------------------------------------------------------------------------------
CLASSES = {}
def __find_global(modulename, classname):
global CLASSES
return CLASSES[classname]
def loads(s):
f = cStringIO.StringIO(s)
p = cPickle.Unpickler(f)
p.find_global = __find_global
return p.load()
... your classes here
################################################################################
#
# This MUST be the last function/code defined in this module so that if finds
# ALL the classes in this module.
#
################################################################################
def findClasses(frame):
d = {}
for o in frame.f_locals.itervalues():
if inspect.isclass(o):
d[o.__name__] = o
return d
CLASSES = findClasses(inspect.currentframe())
# lcm
Nigel Campbell wrote: Dumbing down the database doesn't protect it from anything but a lack of willingness to learn SQL.
In this case, I believe Ian is trying to avoid having to use yet another server to provide simple application functionality. You may argue that this is not scalable, but on a small-site level, it can be practical.
And perhaps a corollary: I'm not a big fan of using lots of stored procedures and other related features (many uses of triggers and views, for instance). I'm trying to protect the data from the code, and putting code in the database compromises that.
Nigel has some good points on this above but I can't help adding my own comments. I suspect Ian's thoughts on this are colored by thoughts about SQLObject. At the moment SQLObject is an excellent (but limited) ORM. Ian is no doubt trying to find the balance between what belongs in SQLObject and what belongs in the database.
My experience is that data consistency rules belong in the database. For instance, audit tables should always be maintained by the database itself (where possible) via triggers. As Nigel said, other applications are going to use that database and you can nigh-on guarantee that they won't play by exactly the same rules unless you force them to by encoding the rules in the database itself.
Ditto constraints on the data of all types (referential, uniqueness, value).
The difficulty, as always, is making SQLObject treat database engines with different features in a consistent way, papering over the cracks.
# Ian Sparks
One key point I made is that I'm no longer convinced that OR mapping layers add much value to a language like Python. Fowler's book Patterns of Enterprise Application Architecture is a good source for some examples of more data-centric approaches to this problem. I did do some work on a Python ORML but never finished it after getting dragged off onto another project. There's a working prototype of the top end (a database row cache and __getattr__()/__setattr__() based object-row mapping), but the database layer isn't done beyond some initial fiddling. I should find some time and finish it.
The resulting effort was surprisingly hard to write. It looks simple until you try explaining how it works to someone else. ORML's aren't easy things to do if you want to take care of complex relationships. Now I'm not convinced that they add much value to Python as Python has fairly powerful native data manipulation capabilities to begin with.
To take the 'simple infrastructure' argument a layer further - if you have an RDBMS for a schema with (say) 5-10 tables it might be overkill, adding a relatively complex piece of infrastructure for little gain. Consider using ZODB, metakit or another lightweight storage engine. As an earlier poster said, they aren't so scalable, but for simple applications they add much less baggage than a client-server DBMS.
# Nigel Campbell
Nigel, perhaps you should check out SQLObject. I'm not going to try to convince you of its merits, you should look and make your own decision.# Ian Sparks
For the record, I certainly think data integrity checks in the database are good. "Auditing" in the database is probably the right thing too, but that implies bureaucratic requirements. "Logging" means the same thing, but with a different motivation. The issue with doing these in the database is that all the interesting information has to be passed into the database -- like who is performing the change, and potentially other contextual information (e.g. a transaction ID, so you can view the update as part of the atomic transaction it participates in). So, I might not put "logging" logic into the database, because logging doesn't have to be enforced the same way auditing does. (For instance, in my database-related logs I usually like to give an indication of what the larger action was -- e.g., moving something vs. creating something, even if both operations result in an insert).
In a lot of my experience I find there are parts of the system that live in the database, and parts that don't. Well, that's why the database isn't an application server -- though not everyone agrees, hence many of Oracle's efforts to make Oracle an app server, and the recent experiment someone did embedding Zope in PostgreSQL. If it's only transient UI logic that lives outside of the database this seems innocuous, but when you start doing network calls, writing files to disk, and so on, the "center" starts to move out of the database and into your code, and the database seems like one of many appendages of your code. This is when logic in the database feels like a burden, and where it also feels incomplete, since the database's perspective seems much more limited than my application's perspective (unless, I suppose, you use lots of stored procedures).# Ian Bicking
Why didn't you just switch to xmlpickle?
I always think "how easy would it be to read the data using a program written in AWK". If you can manipulate the data in AWK then there is a good chance that you can go back to the project in five years time and re-use the data even though the program that generated it may be un-runnable. I say AWK because it is a simple, but not too simple language; tabular formats can be the easiest to process in AWK (but CSV/TSV neds careful thought , and documentation on how to treat strings containing separators/string terminators); tree structured data has to be carefully laid out, for example by putting list opening/closing brackets on a line by themselves. Once the output format is AWK freindly, then it becomes Python/Perl/TCL friendly too.# Paddy3118
... Oh, and if their is a natural /useful order that can be applied to the data, save it in sorted form.# Paddy3118
The key thing is having correct documentation for your file format, otherwise you're on a reverse engineering spree next time you need to work with that file. Working with binary files is quite easy, especially with an appropriate supporting framework (I've 90% written two for Python, neither really released though). However, data that is tightly bound to some fixed schema, like SQL or XML (sometimes) is definitely easier to reverse engineer than anything else (AWK-able files included).


2C-T-21 is a white powder that I was able to dissolve in water at a concentration of 1mg/ml after considerable shaking. The taste is not at all unpleasant, reminding me of cocaine (without the numbness).
I started with a 6mg dose, thinking it would be a barely threshold dose. Wrong! But it turned out to be a most enjoyable and rewarding experience. I was out of town on a business trip. My mindset was relaxed, energetic, open to new experiences. The setting was a small pub around the corner from my hotel, where the staff and customers were pretty friendly.
The come-up occurred over the course of one and a half hours, with first alerts coming at about the 45 minute mark. I had recently had a light dinner (a small roast beef sandwich and a beer) and perhaps on an empty stomach, the onset would have been quicker. The initial signs were a little bit of dizziness (head rush I suppose) and difficulty with linear thinking. As time went on, I began to notice euphoria. There was no nausea at all, and no particular rush of energy.
The peak lasted for two hours. I was definitely loved up; I wanted to give people money, buy them drinks. I was clumsy and had problems with linear thinking; however, I was able to carry on conversations reasonably well. Fortunately I talked to a girl who is way into Eastern mysticism so my 'deep thoughts' did not freak her out too much. It was not too difficult to connect with other people emotionally although my non-linearity was problematic at times, found myself constantly having to get back to the point.
I thought there might be some visual effects lurking below the surface. The metallic-looking cover of a matchbook seemed iridescent and fascinating. The bar was lit in part with marquee-lights, and they seemed to take on a warm glow, like candle-light. During the peak I felt a little surge of energy in the legs but not much. Definite jaw clenching, and a dry mouth too, probably at least some dehydration. Really needed something to do with the mouth. I ate a lot of ice and smoked way too many cigarettes. Light touches felt really good, in an MDMA like way, although not quite to that extent. Still a very sensual drug nonetheless. I'll bet french kissing is to die for on this drug.
I had wonderful feelings of contentment. I kept thinking about heartspace and how cool it is to be able to communicate emotionally with someone. It struck me at one point that everything is perfect, because any particular thing is nothing more or less than exactly what it is, no matter what we name it, or what we try to make of it.
I kept smelling something like burnt popcorn. I didn't see any popcorn in there, and the smell seemed to come up at various places in the room. Unclear whether this was exaggerated sensitivity to an actual smell, or an outright hallucination.
Gentle comedown for an hour and a half, ending with being abruptly re-deposited in reality five and a half hours after the dose. After-effects included mild chilling. Moderate difficulty getting to sleep (I have a touch of restless leg syndrome, and all the phenylethylamines send me into a spin, literally, when I try to go to bed). No hangover the next day.
Overall, I liked this a lot.
Compared with a 12-mg dose of 2C-I, there were fewer visuals with -21 but much more empathy.  Not sure I could see trouble coming and so I avoid any place where people get into fights. Much more sensitive to the vibe around me on -21 and probably much better able to avoid offending anyone. 2C-T-21 is not nearly as stimulating as 2C-I or MDMA. In fact, at 6mg I would describe it as relaxing.
Compared with MDMA, the energy level was less, and I was less able to carry on a coherent conversation. It is not as sensual as MDMA, but then nothing is. By the same token, I did not feel nearly as washed out the next day with -21.
This may seem heretical, but except for my first MDMA experience, I've found recent experiences somewhat less satisfactory, whether due to tolerance or black market issues or whatever. But I was very happy with with -21's ability to promote emotional closeness and physical sensuality. If any visuals come out at higher doses, I might like it more than MDMA. Granted, I'm at an age where I don't really like being spastically hyperactive, or hung over for three days, so the mellowness of -21 is an advantage to me. With that in mind I doubt -21 will prove to be a good club drug. Much better for lounging around with friends, whether new friends or old friends. I can't wait to try this with some close friends because I think the potential for bonding and intimacy is great.
I would like to try lower doses as well as higher doses. I really think I could make it through a dinner party without getting busted on maybe 4-5 mg, and that would probably be a really cool experience. We will also try 8mg to see if any of those visual effects blossom.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Class PatternStack
Represents a variable size last-in-first-out (LIFO) collection of instances of
Inheritance
Implements
Inherited Members
Namespace: System.Collections.Specialized
Assembly: cs.temp.dll.dll
Syntax
public sealed class PatternStack : ICollection, IEnumerable, IEnumerable<Node>, IReadOnlyCollection<Node>
Remarks
This is primarily intended to help with pattern expressions in bespoke languages.
Properties
Count
Declaration
public int Count { get; }
Property Value
| Type | Description |
|---|---|
| System.Int32 |
IsSynchronized
Declaration
public bool IsSynchronized { get; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
SyncRoot
Declaration
public object SyncRoot { get; }
Property Value
| Type | Description |
|---|---|
| System.Object |
Methods
Alternate()
Declares the two top elements of the stack as alternates of each other, and then pushes the resulting pattern back on.
Declaration
public void Alternate()
Alternate(Pattern)
Declares the specified p
and the top element of the stack as alternates of each other, and then pushes the resulting pattern back on.
Declaration
public void Alternate(Pattern p)
Parameters
| Type | Name | Description |
|---|---|---|
| Pattern | p | A |
Capture(out Capture)
Declares the top element of the stack should be captured into Capture
for later reference
Declaration
public void Capture(out Capture Capture)
Parameters
| Type | Name | Description |
|---|---|---|
| Capture | Capture | A Capture object to store into. |
Concatenate()
Concatenates the two top elements of the stack so that the top comes after the next, and then pushes the resulting pattern back on.
Declaration
public void Concatenate()
Concatenate(Pattern)
Concatenates the specified p
and the top element of the stack so that p
comes after the top element, and then pushes the resulting pattern back on.
Declaration
public void Concatenate(Pattern p)
Parameters
| Type | Name | Description |
|---|---|---|
| Pattern | p | A |
Negate()
Declares the top element of the stack as negated, and then pushes the resulting pattern back on.
Declaration
public void Negate()
Optional()
Declares the top element of the stack as optional, and then pushes the resulting pattern back on.
Declaration
public void Optional()
Peek()
Returns the object at the top of the PatternStack without removing it.
Declaration
public Pattern Peek()
Returns
| Type | Description |
|---|---|
| Pattern |
Pop()
Removes and returns the
Declaration
public Pattern Pop()
Returns
| Type | Description |
|---|---|
| Pattern |
Push(Pattern)
Inserts an object at the top of the PatternStack.
Declaration
public void Push(Pattern Pattern)
Parameters
| Type | Name | Description |
|---|---|---|
| Pattern | Pattern |
Span()
Declares the top element of the stack as spanning, and then pushes the resulting pattern back on.
Declaration
public void Span()
Explicit Interface Implementations
ICollection.CopyTo(Array, Int32)
Declaration
void ICollection.CopyTo(Array array, int index)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Array | array | |
| System.Int32 | index |
IEnumerable.GetEnumerator()
Declaration
IEnumerator IEnumerable.GetEnumerator()
Returns
| Type | Description |
|---|---|
| System.Collections.IEnumerator |


| |
There are a
couple of things below you really
need to read to use FOX Media Center.
|
|
|
- The brains of FOX Media Center are all in the task tray icon
like the one on the left. Double click on the music icon to show
the playlist window. Or right mouse click on the icon for a
popup menu. If you close the playlist window the program is
still running in the task tray, you need to select exit from the
popup menu. I like to close the playlist window with the music
still playing and just control the program from the popup menu
in the task tray.
- To create a playlist click on the eject button on the
playlist window. (At least on the skins I did). Then click 'New
Playlist' and type in a name. Drag and drop all the songs you
want for that playlist onto the playlist manager window. Then
click 'Play Selected' or 'Save All' to save your playlist. If
you have heaps of songs you can try creating a random playlist.
Click the 'New Random' button. In the New Random Dialog you need
to enter a few things. Max number of files is how many files
will randomly be added to the playlist. Next hit the 'Browse'
button to select a directory that has a lot of songs in it. Then
once you have a directory click the 'Add Directory' button. You
can add as many directories as you like. Below that is file
type. If you want to add MP3 files, click 'Add File Type'. You
can add as many files types as you like. eg. *.mpg or *.wma.
When selecting random files it will only select files that match
these file types you add. If you want the list to play totally
random songs each time you choose the list click the check box
at the bottom. 'Choose random files each time ...' Then just hit
Create and you have a new random playlist.
- Check out the popup menu options. Either from the menu
button on the playlist or by right clicking on the task tray.
You can access the settings dialog from here. The settings work
great for me but maybe not for you. eg start when windows starts
and hide in task tray rather than popup the playlist. You can
change skins from the menus.
- Another cool feature is the Activate Timed Shutdown dialog.
You access it from the popup menu. You can choose to play music
for a certain time period and then have the computer turn off. I
like it to slowly lower the volume over time while I am going to
sleep. Or if you are watching a movie in bed you can have it
turn off the computer after the movie has finished. Just select
one or the other and click the 'Start Timer' button. To cancel
the timer just click the popup menu one more time.
|
|


Don't eat romaine grown in Salinas, California, Canadian officials warn
Canadian health officials are warning consumers to avoid romaine lettuce grown in Salinas, Calif., because of another food poisoning outbreak
by Canadian PressCanadian health officials are warning consumers to avoid romaine lettuce grown in Salinas, Calif., because of another food poisoning outbreak.
The notice comes almost exactly one year after a similar outbreak led to a blanket warning about romaine, ranging from whole heads to pre-cut salad mixes.
The Public Health Agency of Canada says one patient in Manitoba last month suffered from an illness bearing a "similar genetic fingerprint" to illnesses reported in an ongoing U.S. investigation into an outbreak of E. coli in the Golden State.
Health officials say an outbreak is not occurring in Canada, but romaine from northern California is imported north of the border this time of the year.
The agency says it is implementing "new actions" at the border to prevent the tainted lettuce from coming into Canada.
Leafy greens can become contaminated after contact with feces from infected animals via soil, water or improperly composted manure.
This is the fourth E. coli outbreak linked to romaine lettuce affecting Canadian consumers in the last two years.
Story written by The Canadian Press with files from The Associated Press.


Welcome to Soko-pup!
Up
Down
Left
Right
Or use the arrow keys!
Board Editor
############################ # # # * p * # # # # b # # # # b ###### # # # # # # # * # # # # b* # b # # b # # # # ## ### # # # # # # #*# # # ### # ############################
Update Board
Icons made by
Freepik
from
www.flaticon.com
is licensed by
CC 3.0 BY


☰ Menu
Team Moonmist Pokémon Center
☰ Menu
Home
Gallery
Pokédex
Game
About Us
Template
Site designed by Team Moonmist - CITW165 2019
©


Timon
Total Supply : 1,000,000,000,000,000
Protocol
100% Community Driven
We are 100% community driven: Fair launch, locked LP and the biggest burn in history.
Static Rewards System
Users can earn Timon tokens simply by holding coins in their wallets. 5% of fees on each transaction go directly to the holders, while another 5% is auto-locked to liquidity.
Limited Supply
50% of TMN will be burned after launch, removing them from circulation. Timon continues to burn coins, so the number of coins in circulation will only continue to be reduced over time.
Secure & Immutable
Timon is smart contract-based crypto which uses the BEP-20 interface, making it secure and immutable.
Investment Projects
The Timon team has many other projects in line for its investors, decentralized exchange, called TimonSwap, coming in the near future.
Road map
Launch
Website and Timon token launching
TMN Promotion
PancakeSwap Listing
Campaigns
Coingecko Listing
CoinMarketCap Listing
Further partnerships
Timon-Swap
Launch TimonSwap
Exchanges listing
DeFi Services
Staking and Farming launching


I am Bachelor’s Degree in Computer Science with 10+ years of experience developing software. I would like to provide my experience in favor of the company to develop new solutions, maintain existing ones and learning new technologies. I have experience in projects of retail systems, HRMS, financial, educational and real estate.
Conducted software development projects on customers, using C# .NET, API, Asp.NET MVC and Bootstrap and Angular, using Oracle MS SQL. Ranked as top 5 of one of the best teams who have completely completed sprints for 2 consecutive years.
Consulting in several projects with PHP,.NET (C# and Vb), Restful web services, Asp.NET, MVC, using Oracle MS SQL and MySQL. Supervised up to 20 employees in several sprints.
I triple product billing with innovations and reformulating the system it was responsible for, using Vb.NET with Oracle, MS SQL Server, and Access. Using the Scrum methodology to conduct the projects.
Responsible for migrating Delphi products to .NET. Conducting software development using C# .NET and Asp.NET MVC.
Development of several projects using Delphi with Oracle and MS SQL. I increased by 20% the quantity of customers in one year.
Responsible for the system support and decision of the company using Delphi, with MS SQL and displaying the information in the internal portal using PHP with MySQL.
In addition to being a developer, I take advantage of my time with my family.
I like to watch series, MMA fights and soccer.
With free time I like to cook for family, and I like to explore new technological advances in the world of development.


Data Structures | |
| struct | mem_pool |
| Memory pool. More... | |
Functions | |
| void | mem_pool_init (struct mem_pool *pool, void *start, size_t size, size_t objsize, unsigned int align_order) |
| Initialize a memory pool. | |
| void | mem_pool_init_physmem (struct mem_pool *mempool, struct physmem_pool *phys_pool, unsigned int nr_objects, size_t objsize, unsigned int align_order) |
| Initialize a memory pool using the physmem allocator. | |
| void * | mem_pool_alloc (struct mem_pool *pool) |
| Allocate an object from a memory pool. | |
| void | mem_pool_free (struct mem_pool *pool, const void *obj) |
| Free an object previously allocated from a memory pool. |
A memory pool contains a number of objects of the same size that can be allocated in constant time. This is useful for allocating request structures, etc.
Memory pool objects are managed in Last-In-First-Out (LIFO) order to maximize the chances of allocating a cache-hot object.
| void * mem_pool_alloc | ( | struct mem_pool * | pool | ) |
Allocate an object from a memory pool.
| pool | The memory pool from which the object is allocated. |
Referenced by buffer_alloc(), dataflash_alloc_req(), and membag_alloc().
| void mem_pool_free | ( | struct mem_pool * | pool, | |
| const void * | obj | |||
| ) |
Free an object previously allocated from a memory pool.
The caller is responsible for making sure obj was originally allocated from pool. If an object is freed into a different pool, the integrity of the pool can no longer be guaranteed.
| pool | The memory pool which the object belongs to. | |
| obj | The object to be freed. |
Referenced by buffer_free(), dataflash_free_req(), and membag_free().
| void mem_pool_init | ( | struct mem_pool * | pool, | |
| void * | start, | |||
| size_t | size, | |||
| size_t | objsize, | |||
| unsigned int | align_order | |||
| ) |
Initialize a memory pool.
This function will initialize a memory pool, populating its freelist with objects tightly packed into the specified memory range.
All objects in the pool are guaranteed to be aligned to a multiple of bytes. For example, if align_order is 4, each object will start on a 16-byte boundary.
| pool | The memory pool to be initialized. | |
| start | The memory area to be used for object storage. | |
| size | The size of the memory area in bytes. | |
| objsize | The size of each object in bytes. | |
| align_order | log2 of the minimum object alignment in bytes. |
Referenced by membag_pool_init_physmem().
| void mem_pool_init_physmem | ( | struct mem_pool * | mempool, | |
| struct physmem_pool * | phys_pool, | |||
| unsigned int | nr_objects, | |||
| size_t | objsize, | |||
| unsigned int | align_order | |||
| ) |
Initialize a memory pool using the physmem allocator.
This function will grab enough physical memory for nr_objects and use this to initialize mempool.
| mempool | The memory pool to be initialized. | |
| phys_pool | The physical memory pool from which to grab memory | |
| nr_objects | The number of objects in the pool | |
| objsize | The size of each object in bytes. | |
| align_order | log2 of the minimum object alignment in bytes. |
Referenced by buffer_pool_init().


We love companies that support employes' continual education. Therefore, if your company sends >20% of the engineering team OR >10 developers to PyBay with the corporate rate, we'll feature your company's logo among the Fans of Python.
Your employer is not reimbursing your ticket? On a tight budget or in-between jobs? A student? We've got you covered with individual tickets. However, please get your ticket ASAP - prices go up as the allotted tickets at each price tier sell out.
Want to add to your conference by deep diving with some of the top educators in the python ecosystems? Or skip the conference and just take the pre-conference workshops? Tickets for full-day a half-day work shops are available on an a la carte bases.
Have too much going on but still want to join in on the fun to geek out with other Pythonistas and attend some talks? Come on Saturday or Sunday, your call. Make it happen.
Want trade your talents in for a discount? We have 20 work-trade slots during the conference where you pay only 1/3 the lowest price, and we have roles handling pre-conference tasks where we will comp your ticket. See what help we need and apply away!
UCSF Mission Bay Conference Center
1500 Owens Street,
San Francisco, CA 94158
See Map
TBD
Interested in becoming a sponsor? Check out our Options


So this one time I had an apartment in Reñaca, Chile that I shared with two guys. We got along pretty well. We all wanted to do our best at our work and produce great things. Until one of the guys started bringing his girlfriend around. She was super sweet and an overall great person. However, she would stay for up to a week at a time and leave dishes everywhere. Everyday I would come home from the coworking space I was using to an apartment that was dirty.
It was incredibly frustrating at first. I felt like I couldn't come home and be comfortable in my own home because there was this person that would leave it messy all the time. The more I examined my feelings and the situation, the more I realized she was not really at fault. She didn't know it frustrated me. She wasn't doing it to spite me or hurt me.
We ended up having a house meeting and letting our friend know that we had no problem with her staying with us but we needed to establish some rules. We agreed on a set of guidelines that we were all happy with and continued living together happily until I left to come back to the united states. What I really gained from this experience was there is no reason to keep a frustration bottled up. It will only build without solving the issue. The best course of action is to always address it in a constructive and friendly manner. That is the only way to be certain it will have the best outcome.


Photography License Using attr: cf-conditional to make conditional form flows. For documentation and more info see Wiki


{% extends 'base.html'%} {%block title%}Introduction{%endblock%} {% block content %}
Environmental degradation can be seen as a serious threat to our healthy existence on the planet. Causes of this degradation include depletion of natural resources and pollution of our air, water and soil.
Visit the about page to learn more!


Styled HTML Checkboxes
Published: July 26, 2018
Last updated: January 13, 2022
Cross-browser styling for native HTML checkboxes.
Pattern Demos
Additional demos can be found in the examples provided in the blog post One last time: custom styling radio buttons and checkboxes.
Pattern Details
Pattern Markup: Restyled Checkbox

<input type="checkbox" id="s_input_1" checked>

Option 1

Pattern Markup: Visually Hidden Checkbox

<input type="checkbox" id="c_input_1" checked>

Option 1

When customizing any form control, it must remain accessible to users. This includes those that navigate the web with their keyboard, along with those using assistive technologies (AT). Relying on HTML's native checkbox control will help ensure that all the necessary keyboard functionality and information exposed to browsers' accessibility trees (and thus then to AT) remains intact.
Without using the native checkbox, all expected functionality, including keyboard focus and appropriate information exposed to AT (such as screen readers), would need to be rewritten using JavaScript and necessary ARIA attributes. This would significantly inflate the development effort needed to create a custom styled checkbox.
What follows are breakdowns of the two methods of creating custom styled checkboxes, as per the markup examples shown previously.
Restyled checkbox details
The most important thing to note about directly styling checkbox controls is that their inherent appearance needs to be reset by the CSS property appearance: none
. Use the -webkit-
prefix for this property if you need to target browsers where the unprefixed property is not supported.
Note that Internet Explorer and pre-Chromium Edge do not support this prefixed property, so their direct styling of checkboxes will be limited. These browsers do support a ::-ms-check
selector, which can be used for legacy styling.
For more information on directly restyling checkboxes, please read One last time: custom styling radio buttons and checkboxes.
Visually hidden checkbox details
Previously, this had been the most robust method to create custom styles for checkboxes while still relying on the native HTML checkbox control - rather than using ARIA to create a fully custom checkbox. This technique is recommended only if you are in a situation where directly styling the native checkbox control is not a robust option for you (i.e., needing to support IE11 while also not being able to live with the fact that designs should be allowed to degrade when using outdated technology).
For the visually hidden checkboxes, the primary purpose of the wrapping element (div
with the .c-cb
class) is to act as a styling hook. The element uses position: relative;
to keep absolute positioned pseudo elements within the bounds of the wrapping element, mitigating potential quirks that could result from another ancestor element's position property.
The form control's label
::before
and ::after
pseudo elements are used to create a visual "checkbox" that can be styled as you see fit. The example on this page merely recreates a recognizable, but custom, checkbox design.
The appearance of the custom checkbox is contingent on current state of the native visually hidden checkbox. :checked
, and :focus
states, along with a potential disabled
state all serve as hooks to visually change the styling of the custom checkbox.
Ensure proper styling for all states and situations
Regardless of which restyling method you choose (directly styling the native checkbox, or using a visually hidden checkbox) you will need to consider all the various states (checked, unchecked, indeterminate, focus) as well as media query styling adjustments (high contrast, dark mode, etc.) that restyling these controls will require. Note that restyling the checkbox directly will make some of these tasks easier (e.g., Windows High Contrast will be more likely to color the checkbox as expected when changing themes. But creating a faux custom checkbox will require additional effort to ensure the proper colors theme colors are respected).
Affects on Screen Reader Announcements?
With either styling method, the native checkbox remains in the DOM, and is the focusable element that will be interacted with by all users. These styling methods do not alter the way a screen reader will announce the checkboxes when focused by the Tab key.
Specifically for the visually hidden checkbox, people might think to hide it with a standard "visually-hidden" or "sr-only" CSS ruleset. These popular rulesets often include position: absolute
and squish the native input
down to a 1px by 1px invisible dot on the screen. Using this method to visually hide the checkbox will retain its keyboard accessibility, but impose screen reader quirks that should be avoided.
For instance, with NVDA 2018.3.2 and Firefox 62 to 64, using position: absolute
to remove checkboxes from the normal DOM flow creates a separate focus stop when navigating with the virtual cursor. This means that where using the down arrow key to navigate through the document would typically highlight (virtually focus) a native checkbox once, it instead highlights it twice.
This double virtual focus issue doesn't occur with unstyled checkboxes with Firefox + NVDA. This position: absolute
behavior also does not occur with Chromium browsers paird with NVDA.
A user can hit the up arrow or down arrow keys to navigate between checkboxes and have their accessible names announced. However, in Firefox + NVDA, when navigating with the down arrow key NVDA will announce "checkbox [check or unchecked]". A second press of down arrow will announce "clickable [accessible name of the checkbox]". Note this separation of the form control from its accessible name does not occur when navigating by X or F keys, nor when using the Tab key to navigate the controls.
Along with the NVDA + position: absolute
announcement quirk, using standard visually hidden CSS to hide native checkboxes off screen, or as a single pixel in the document, will mean that some screen reader users will likely be unable to locate a checkbox.
For instance, people searching by touch, or using a mouse while a screen reader announces what is being hovered (NVDA Mouse setting, "Report role when mouse enters object" turned on, or when using ZoomText Fusion and mouse hovering a custom checkbox).
To mitigate a checkbox role not being announced to these people, the checkboxes have been positioned on top of their pseudo element styled counterparts (position: relative;
with a z-index
). The native checkbox remains visually hidden, but is announces as if it were not (as expected).
VoiceOver on macOS 10.13.6 + Safari 12.0.2
When re-checking the checkboxes after the latest releases of macOS and Safari, if navigating by Tab key or VO cursor, checkboxes will double announce their label. For instance: Option 1. Option 1.
. This only occurs if the checkbox precedes its label
. If the checkbox comes after the label
, or within it, in the DOM order, this behavior will not occur. This behavior does not occur when using Chrome + VoiceOver. (Bug filed: 45506356)
Mixed checkboxes
Use the indeterminate
IDL attribute to indicate when a checkbox is in a "mixed" state. It's important to use this IDL attribute, and avoide aria-checked=mixed
, because browsers should ignore that attribute on native checkboxes, since browsers are supposed to ignore ARIA attributes that have native HTML equivalents. In this case, aria-checked
is meant to be overwritten by the checked
state of the form control. Webkit has a bug with exposing the 'mixed' state (last checked Jan 2022) of a native checkbox, regardless of if you use indeterminate
or aria-checked=mixed
.
Continue reading
For additional information about creating minimal markup patterns for radio button and checkboxes, you should check out: