text:
|Web site:
Python is an interpreted, interactive, object-oriented programming language. It incorporates modules, exceptions, dynamic typing, very high level dynamic data types, and classes. Python combines remarkable power with very clear syntax. It has interfaces to many system calls and libraries, as well as to various window systems, and is extensible in C or C++. It is also usable as an extension language for applications that need a programmable interface. Finally, Python is portable: it runs on many Unix variants, on the Mac, and on PCs under MS-DOS, Windows, Windows NT, and OS/2.
To find out more, start with the Beginner's Guide to Python.
Here's a very brief summary of what started it all, written by Guido van Rossum:
I had extensive experience with implementing an interpreted language in the ABC group at CWI, and from working with this group I had learned a lot about language design. This is the origin of many Python features, including the use of indentation for statement grouping and the inclusion of very-high-level data types (although the details are all different in Python).
I had a number of gripes about the ABC language, but also liked many of its features. It was impossible to extend the ABC language (or its implementation) to remedy my complaints -- in fact its lack of extensibility was one of its biggest problems. I had some experience with using Modula-2+ and talked with the designers of Modula-3 and read the Modula-3 report. Modula-3 is the origin of the syntax and semantics used for exceptions, and some other Python features.
I was working in the Amoeba distributed operating system group at CWI. We needed a better way to do system administration than by writing either C programs or Bourne shell scripts, since Amoeba had its own system call interface which wasn't easily accessible from the Bourne shell. My experience with error handling in Amoeba made me acutely aware of the importance of exceptions as a programming language feature.
It occurred to me that a scripting language with a syntax like ABC but with access to the Amoeba system calls would fill the need. I realized that it would be foolish to write an Amoeba-specific language, so I decided that I needed a language that was generally extensible.
During the 1989 Christmas holidays, I had a lot of time on my hand, so I decided to give it a try. During the next year, while still mostly working on it in my own time, Python was used in the Amoeba project with increasing success, and the feedback from colleagues made me add many early improvements.
In February 1991, after just over a year of development, I decided to post to USENET. The rest is in the Misc/HISTORY file.
Python is a high-level general-purpose programming language that can be applied to many different classes of problems.
The language comes with a large standard library that covers areas such as string processing (regular expressions, Unicode, calculating differences between files), Internet protocols (HTTP, FTP, SMTP, XML-RPC, POP, IMAP, CGI programming), software engineering (unit testing, logging, profiling, parsing Python code), and operating system interfaces (system calls, filesystems, TCP/IP sockets). Look at the table of contents for the Library Reference to get an idea of what's available. A wide variety of third-party extensions are also available. Consult the Python Package Index to find packages of interest to you.
Python versions are numbered A.B.C or A.B. A is the major version number -- it is only incremented for really major changes in the language. B is the minor version number, incremented for less earth-shattering changes. C is the micro-level -- it is incremented for each bugfix release. See PEP 6 for more information about bugfix releases.
Not all releases are bugfix releases. In the run-up to a new major release, a series of development releases are made, denoted as alpha, beta, or release candidate. Alphas are early releases in which interfaces aren't yet finalized; it's not unexpected to see an interface change between two alpha releases. Betas are more stable, preserving existing interfaces but possibly adding new modules, and release candidates are frozen, making no changes except as needed to fix critical bugs.
Alpha, beta and release candidate versions have an additional suffix. The suffix for an alpha version is "aN" for some small number N, the suffix for a beta version is "bN" for some small number N, and the suffix for a release candidate version is "cN" for some small number N. In other words, all versions labeled 2.0aN precede the versions labeled 2.0bN, which precede versions labeled 2.0cN, and those precede 2.0.
You may also find version numbers with a "+" suffix, e.g. "2.2+". These are unreleased versions, built directly from the subversion trunk. In practice, after a final minor release is made, the subversion trunk is incremented to the next minor version, which becomes the "a0" version, e.g. "2.4a0".
See also the documentation for sys.version, sys.hexversion, and sys.version_info.
Not really. You can do anything you want with the source, as long as you leave the copyrights in and display those copyrights in any documentation about Python that you produce. If you honor the copyright rules, it's OK to use Python for commercial use, to sell copies of Python in source or binary form (modified or unmodified), or to sell products that incorporate Python in some form. We would still like to know about all commercial use of Python, of course.
See the PSF license page to find further explanations and a link to the full text of the license.
The latest Python source distribution is always available from python.org, at http://www.python.org/download/. The latest development sources can be obtained via anonymous subversion from SourceForge, at http://svn.python.org/projects/python/trunk.
The source distribution is a gzipped tar file containing the complete C source, LaTeX documentation, Python library modules, example programs, and several useful pieces of freely distributable software. This will compile and run out of the box on most UNIX platforms.
Older versions of Python are also available from python.org.
All documentation is available on-line, starting at http://www.python.org/doc/.
The standard documentation for the current stable version of Python is also available at http://docs.python.org/.
The LaTeX source for the documentation is part of the source distribution. If you don't have LaTeX, the latest Python documentation set is available by anonymous FTP in various formats such as PostScript and HTML. Visit the above URL for links to the current versions.
There are numerous tutorials and books available. Consult the Beginner's Guide to find information for beginning Python programmers, including lists of tutorials.
Consult the list of python.org mirrors at http://www.python.org/Mirrors.html.
There is a newsgroup, comp.lang.python, and a mailing list, python-list. The newsgroup and mailing list are gatewayed into each other -- if you can read news it's unnecessary to subscribe to the mailing list. comp.lang.python is high-traffic, receiving hundreds of postings every day, and Usenet readers are often more able to cope with this volume.
Announcements of new software releases and events can be found in comp.lang.python.announce, a low-traffic moderated list that receives about five postings per day. It's available as the python-announce mailing list.
More info about other mailing lists and newsgroups can be found at http://www.python.org/community/lists.html.
All releases, including alphas, betas and release candidates, are announced on the comp.lang.python and comp.lang.python.announce newsgroups. All announcements also appear on the Python home page, at http://www.python.org/; an RSS feed of news is available.
You can also access the development version of Python through subversion. See http://www.python.org/dev/devfaq.html#subversion-svn for details.
To report a bug or submit a patch, please use the relevant service from the Python project at SourceForge.
Bugs: http://sourceforge.net/tracker/?group_id=5470&atid=105470
Patches: http://sourceforge.net/tracker/?group_id=5470&atid=305470
You must have a SourceForge account to report bugs; this makes it possible for us to contact you if we have follow-up questions. It will also enable SourceForge to send you updates as we act on your bug.
For more information on how Python is developed, consult the Python Developer's Guide.
It's probably best to reference your favorite book about Python.
The very first article about Python is this very old article that's now quite outdated.
Guido van Rossum and Jelke de Boer, "Interactively Testing Remote Servers Using the Python Programming Language", CWI Quarterly, Volume 4, Issue 4 (December 1991), Amsterdam, pp 283-303.
Yes, there are many, and more are being published. See the python.org Wiki at http://www.python.org/moin/PythonBooks for a list.
You can also search online bookstores for "Python" and filter out the Monty Python references; or perhaps search for "Python" and "language".
It's currently in Amsterdam, graciously hosted by XS4ALL. Thanks to Thomas Wouters for his work in arranging python.org's hosting.
At the same time he began implementing Python, Guido van Rossum was also reading the published scripts from "Monty Python's Flying Circus" (a BBC comedy series from the seventies, in the unlikely case you didn't know). It occurred to him that he needed a name that was short, unique, and slightly mysterious, so he decided to call the language Python.
No, but it helps. :)
Very stable. New, stable releases have been coming out roughly every 6 to 18 months since 1991, and this seems likely to continue. Currently there are usually around 18 months between major releases.
With the introduction of retrospective "bugfix" releases the stability of existing releases is being improved. Bugfix releases, indicated by a third component of the version number (e.g. 2.1.3, 2.2.2), are managed for stability; only fixes for known problems are included in a bugfix release, and it's guaranteed that interfaces will remain the same throughout a series of bugfix releases.
The 2.4.2 release is the most stable version at this point in time.
Probably tens of thousands of users, though it's difficult to obtain an exact count. Python is available for free download, so there are no sales figures, and it's available from many different sites and packaged with many Linux distributions, so download statistics don't tell the whole story either. The comp.lang.python newsgroup is very active, but not all Python users post to the group or even read it. Overall there is no accurate estimate of the number of subscribers or Python users.
See http://www.pythonology.org/success for a list of projects that use Python. Consulting the proceedings for past Python conferences will reveal contributions from many different companies and organizations.
High-profile Python projects include the Mailman mailing list manager and the Zope application server. Several Linux distributions, most notably Red Hat, have written part or all of their installer and system administration software in Python. Companies that use Python internally include Google, Yahoo, and Industrial Light & Magic.
See http://www.python.org/peps for the Python Enhancement Proposals (PEPs). PEPs are design documents describing a suggested new feature for Python, providing a concise technical specification and a rationale. PEP 1 explains the PEP process and PEP format; read it first if you want to submit a PEP.
New developments are discussed on the python-dev mailing list.
In general, no. There are already millions of lines of Python code around the world, so any change in the language that invalidates more than a very small fraction of existing programs has to be frowned upon. Even if you can provide a conversion program, there still is the problem of updating all documentation; many books have been written about Python, and we don't want to invalidate them all at a single stroke.
Providing a gradual upgrade path is necessary if a feature has to be changed. PEP 5 describes the procedure followed for introducing backward-incompatible changes while minimizing disruption for users.
The Python Software Foundation is an independent non-profit organization that holds the copyright on Python versions 2.1 and newer. The PSF's mission is to advance open source technology related to the Python programming language and to publicize the use of Python. The PSF's home page is at http://www.python.org/psf/.
Donations to the PSF are tax-exempt in the US. If you use Python and find it helpful, please contribute via the PSF donation page.
As of August, 2003 no major problems have been reported and Y2K compliance seems to be a non-issue.
Python does very few date calculations and for those it does perform relies on the C library functions. Python generally represents times either as seconds since 1970 or as a (year, month, day, ...) tuple where the year is expressed with four digits, which makes Y2K bugs unlikely. So as long as your C library is okay, Python should be okay. Of course, it's possible that a particular application written in Python makes assumptions about 2-digit years.
Because Python is available free of charge, there are no absolute guarantees. If there are unforseen problems, liability is the user's problem rather than the developers', and there is nobody you can sue for damages. The Python copyright notice contains the following disclaimer:
4. PSF is making Python 2.3 available to Licensee on an "AS IS" basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.3 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
The good news is that if you encounter a problem, you have full source available to track it down and fix it. This is one advantage of an open source programming environment.
Yes. If you want to discuss Python's use in education, then you may be interested in joining the edu-sig mailing list.
It is still common to start students with a procedural (subset of a) statically typed language such as Pascal, C, or a subset of C++ or Java. Students may be better served by learning Python as their first language. Python has a very simple and consistent syntax and a large standard library and, most importantly, using Python in a beginning programming course permits students to concentrate on important programming skills such as problem decomposition and data type design. With Python, students can be quickly introduced to basic concepts such as loops and procedures. They can even probably work with user-defined objects in their very first course.
For a student who has never programmed before, using a statically typed language seems unnatural. It presents additional complexity that the student must master and slows the pace of the course. The students are trying to learn to think like a computer, decompose problems, design consistent interfaces, and encapsulate data. While learning to use a statically typed language is important in the long term, it is not necessarily the best topic to address in the students' first programming course.
Many other aspects of Python make it a good first language. Like Java, Python has a large standard library so that students can be assigned programming projects very early in the course that do something. Assignments aren't restricted to the standard four-function calculator and check balancing programs. By using the standard library, students can gain the satisfaction of working on realistic applications as they learn the fundamentals of programming. Using the standard library also teaches students about code reuse. Third-party modules such as PyGame are also helpful in extending the students' reach.
Python's interactive interpreter enables students to test language features while they're programming. They can keep a window with the interpreter running while they enter their program's source in another window. If they can't remember the methods for a list, they can do something like this:
>>> L = [] >>> dir(L) ['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] >>> help(L.append) Help on built-in function append: append(...) L.append(object) -- append object to end >>> L.append(1) >>> L [1]
With the interpreter, documentation is never far from the student as he's programming.
There are also good IDEs for Python. IDLE is a cross-platform IDE for Python that is written in Python using Tkinter. PythonWin is a Windows-specific IDE. Emacs users will be happy to know that there is a very good Python mode for Emacs. All of these programming environments provide syntax highlighting, auto-indenting, and access to the interactive interpreter while coding. Consult http://www.python.org/editors/ for a full list of Python editing environments.
Starting with Python2.3, the distribution includes the PyBSDDB package <http://pybsddb.sf.net/> as a replacement for the old bsddb module. It includes functions which provide backward compatibility at the API level, but requires a newer version of the underlying Berkeley DB library. Files created with the older bsddb module can't be opened directly using the new module.
Using your old version of Python and a pair of scripts which are part of Python 2.3 (db2pickle.py and pickle2db.py, in the Tools/scripts directory) you can convert your old database files to the new format. Using your old Python version, run the db2pickle.py script to convert it to a pickle, e.g.:
python2.2 <pathto>/db2pickley.py database.db database.pck
Rename your database file:
mv database.db olddatabase.db
Now convert the pickle file to a new format database:
python2.3 <pathto>/pickle2db.py database.db database.pck
The precise commands you use will vary depending on the particulars of your installation. For full details about operation of these two scripts check the doc string at the start of each one.
Guido van Rossum believes that using indentation for grouping is extremely elegant and contributes a lot to the clarity of the average Python program. Most people learn to love this feature after awhile.
Since there are no begin/end brackets there cannot be a disagreement between grouping perceived by the parser and the human reader. Occasionally C programmers will encounter a fragment of code like this:
if (x <= y) x++; y--; z++;
Only the x++ statement is executed if the condition is true, but the indentation leads you to believe otherwise. Even experienced C programmers will sometimes stare a long time at it wondering why y is being decremented even for x > y.
Because there are no begin/end brackets, Python is much less prone to coding-style conflicts. In C there are many different ways to place the braces. If you're used to reading and writing code that uses one style, you will feel at least slightly uneasy when reading (or being required to write) another style.
Many coding styles place begin/end brackets on a line by themself. This makes programs considerably longer and wastes valuable screen space, making it harder to get a good overview of a program. Ideally, a function should fit on onescreen (say, 20-30 lines). 20 lines of Python can do a lot more work than 20 lines of C. This is not solely due to the lack of begin/end brackets -- the lack of declarations and the high-level data types are also responsible -- but the indentation-based syntax certainly helps.
See the next question.
People are often very surprised by results like this:
>>> 1.2-1.0 0.199999999999999996
and think it is a bug in Python. It's not. It's a problem caused by the internal representation of floating point numbers, which uses a fixed number of binary digits to represent a decimal number. Some decimal numbers can't be represented exactly in binary, resulting in small roundoff errors.
In decimal math, there are many numbers that can't be represented with a fixed number of decimal digits, e.g. 1/3 = 0.3333333333.......
In base 2, 1/2 = 0.1, 1/4 = 0.01, 1/8 = 0.001, etc. .2 equals 2/10 equals 1/5, resulting in the binary fractional number 0.001100110011001...
Floating point numbers only have 32 or 64 bits of precision, so the digits are cut off at some point, and the resulting number is 0.199999999999999996 in decimal, not 0.2.
A floating point's repr() function prints as many digits are necessary to make eval(repr(f)) == f true for any float f. The str() function prints fewer digits and this often results in the more sensible number that was probably intended:
>>> 0.2 0.20000000000000001 >>> print 0.2 0.2
Again, this has nothing to do with Python, but with the way the underlying C platform handles floating point numbers, and ultimately with the inaccuracy you'll always have when writing down numbers as a string of a fixed number of digits.
One of the consequences of this is that it is dangerous to compare the result of some computation to a float with == ! Tiny inaccuracies may mean that == fails. Instead, you have to check that the difference between the two numbers is less than a certain threshold:
epsilon = 0.0000000000001 # Tiny allowed error expected_result = 0.4 if expected_result-epsilon <= computation() <= expected_result+epsilon: ...
Please see the chapter on floating point arithmetic in the Python tutorial for more information.
There are several advantages.
One is performance: knowing that a string is immutable makes it easy to lay it out at construction time -- fixed and unchanging storage requirements. This is also one of the reasons for the distinction between tuples and lists.
The other is that strings in Python are considered as "elemental" as numbers. No amount of activity will change the value 8 to anything else, and in Python, no amount of activity will change the string "eight" to anything else.
The idea was borrowed from Modula-3. It turns out to be very useful, for a variety of reasons.
First, it's more obvious that you are using a method or instance attribute instead of a local variable. Reading self.x or self.meth() makes it absolutely clear that an instance variable or method is used even if you don't know the class definition by heart. In C++, you can sort of tell by the lack of a local variable declaration (assuming globals are rare or easily recognizable) -- but in Python, there are no local variable declarations, so you'd have to look up the class definition to be sure. Some C++ and Java coding standards call for instance attributes to have an m_ prefix, so this explicitness is still useful in those languages, too.
Second, it means that no special syntax is necessary if you want to explicitly reference or call the method from a particular class. In C++, if you want to use a method from a base class which is overridden in a derived class, you have to use the :: operator -- in Python you can write baseclass.methodname(self, <argument list>). This is particularly useful for __init__() methods, and in general in cases where a derived class method wants to extend the base class method of the same name and thus has to call the base class method somehow.
Finally, for instance variables it solves a syntactic problem with assignment: since local variables in Python are (by definition!) those variables to which a value assigned in a function body (and that aren't explicitly declared global), there has to be some way to tell the interpreter that an assignment was meant to assign to an instance variable instead of to a local variable, and it should preferably be syntactic (for efficiency reasons). C++ does this through declarations, but Python doesn't have declarations and it would be a pity having to introduce them just for this purpose. Using the explicit "self.var" solves this nicely. Similarly, for using instance variables, having to write "self.var" means that references to unqualified names inside a method don't have to search the instance's directories. To put it another way, local variables and instance variables live in two different namespaces, and you need to tell Python which namespace to use.
Many people used to C or Perl complain that they want to use this C idiom:
while (line = readline(f)) { ...do something with line... }
where in Python you're forced to write this:
while True: line = f.readline() if not line: break ...do something with line...
The reason for not allowing assignment in Python expressions is a common, hard-to-find bug in those other languages, caused by this construct:
if (x = 0) { ...error handling... } else { ...code that only works for nonzero x... }
The error is a simple typo: x = 0, which assigns 0 to the variable x, was written while the comparison x == 0 is certainly what was intended.
Many alternatives have been proposed. Most are hacks that save some typing but use arbitrary or cryptic syntax or keywords, and fail the simple criterion for language change proposals: it should intuitively suggest the proper meaning to a human reader who has not yet been introduced to the construct.
An interesting phenomenon is that most experienced Python programmers recognize the "while True" idiom and don't seem to be missing the assignment in expression construct much; it's only newcomers who express a strong desire to add this to the language.
There's an alternative way of spelling this that seems attractive but is generally less robust than the "while True" solution:
line = f.readline() while line: ...do something with line... line = f.readline()
The problem with this is that if you change your mind about exactly how you get the next line (e.g. you want to change it into sys.stdin.readline()) you have to remember to change two places in your program -- the second occurrence is hidden at the bottom of the loop.
The best approach is to use iterators, making it possible to loop through objects using the for statement. For example, in the current version of Python file objects support the iterator protocol, so you can now write simply:
for line in f: ... do something with line...
The major reason is history. Functions were used for those operations that were generic for a group of types and which were intended to work even for objects that didn't have methods at all (e.g. tuples). It is also convenient to have a function that can readily be applied to an amorphous collection of objects when you use the functional features of Python (map(), apply() et al).
In fact, implementing len(), max(), min() as a built-in function is actually less code than implementing them as methods for each type. One can quibble about individual cases but it's a part of Python, and it's too late to make such fundamental changes now. The functions have to remain to avoid massive code breakage.
Note that for string operations Python has moved from external functions (the string module) to methods. However, len() is still a function.
Strings became much more like other standard types starting in Python 1.6, when methods were added which give the same functionality that has always been available using the functions of the string module. Most of these new methods have been widely accepted, but the one which appears to make some programmers feel uncomfortable is:
", ".join(['1', '2', '4', '8', '16'])
which gives the result:
"1, 2, 4, 8, 16"
There are two usual arguments against this usage.
The first runs along the lines of: "It looks really ugly using a method of a string literal (string constant)", to which the answer is that it might, but a string literal is just a fixed value. If the methods are to be allowed on names bound to strings there is no logical reason to make them unavailable on literals.
The second objection is typically cast as: "I am really telling a sequence to join its members together with a string constant". Sadly, you aren't. For some reason there seems to be much less difficulty with having split() as a string method, since in that case it is easy to see that
"1, 2, 4, 8, 16".split(", ")
is an instruction to a string literal to return the substrings delimited by the given separator (or, by default, arbitrary runs of white space). In this case a Unicode string returns a list of Unicode strings, an ASCII string returns a list of ASCII strings, and everyone is happy.
join() is a string method because in using it you are telling the separator string to iterate over an arbitrary sequence, forming string representations of each of the elements, and inserting itself between the elements' representations. This method can be used with any argument which obeys the rules for sequence objects, inluding any new classes you might define yourself.
Because this is a string method it can work for Unicode strings as well as plain ASCII strings. If join() were a method of the sequence types then the sequence types would have to decide which type of string to return depending on the type of the separator.
If none of these arguments persuade you, then for the moment you can continue to use the join() function from the string module, which allows you to write
string.join(['1', '2', '4', '8', '16'], ", ")
A try/except block is extremely efficient. Actually executing an exception is expensive. In versions of Python prior to 2.0 it was common to use this idiom:
try: value = dict[key] except KeyError: dict[key] = getvalue(key) value = dict[key]
This only made sense when you expected the dict to have the key almost all the time. If that wasn't the case, you coded it like this:
if dict.has_key(key): value = dict[key] else: dict[key] = getvalue(key) value = dict[key]
(In Python 2.0 and higher, you can code this as value = dict.setdefault(key, getvalue(key)).)
You can do this easily enough with a sequence of if... elif... elif... else. There have been some proposals for switch statement syntax, but there is no consensus (yet) on whether and how to do range tests. See PEP 275 for complete details and the current status.
For cases where you need to choose from a very large number of possibilities, you can create a dictionary mapping case values to functions to call. For example:
def function_1 (...): ... functions = {'a': function_1, 'b': function_2, 'c': self.method_1, ...} func = functions[value] func()
For calling methods on objects, you can simplify yet further by using the getattr() built-in to retrieve methods with a particular name:
def visit_a (self, ...): ... ... def dispatch (self, value): method_name = 'visit_' + str(value) method = getattr(self, method_name) method()
It's suggested that you use a prefix for the method names, such as visit_ in this example. Without such a prefix, if values are coming from an untrusted source, an attacker would be able to call any method on your object.
Answer 1: Unfortunately, the interpreter pushes at least one C stack frame for each Python stack frame. Also, extensions can call back into Python at almost random moments. Therefore, a complete threads implementation requires thread support for C.
Answer 2: Fortunately, there is Stackless Python, which has a completely redesigned interpreter loop that avoids the C stack. It's still experimental but looks very promising. Although it is binary compatible with standard Python, it's still unclear whether Stackless will make it into the core -- maybe it's just too revolutionary.
Python lambda forms cannot contain statements because Python's syntactic framework can't handle statements nested inside expressions. However, in Python, this is not a serious problem. Unlike lambda forms in other languages, where they add functionality, Python lambdas are only a shorthand notation if you're too lazy to define a function.
Functions are already first class objects in Python, and can be declared in a local scope. Therefore the only advantage of using a lambda form instead of a locally-defined function is that you don't need to invent a name for the function -- but that's just a local variable to which the function object (which is exactly the same type of object that a lambda form yields) is assigned!
Not easily. Python's high level data types, dynamic typing of objects and run-time invocation of the interpreter (using eval() or exec) together mean that a "compiled" Python program would probably consist mostly of calls into the Python run-time system, even for seemingly simple operations like x+1.
Several projects described in the Python newsgroup or at past Python conferences have shown that this approach is feasible, although the speedups reached so far are only modest (e.g. 2x). Jython uses the same strategy for compiling to Java bytecode. (Jim Hugunin has demonstrated that in combination with whole-program analysis, speedups of 1000x are feasible for small demo programs. See the proceedings from the 1997 Python conference for more information.)
Internally, Python source code is always translated into a bytecode representation, and this bytecode is then executed by the Python virtual machine. In order to avoid the overhead of repeatedly parsing and translating modules that rarely change, this byte code is written into a file whose name ends in ".pyc" whenever a module is parsed. When the corresponding .py file is changed, it is parsed and translated again and the .pyc file is rewritten.
There is no performance difference once the .pyc file has been loaded, as the bytecode read from the .pyc file is exactly the same as the bytecode created by direct translation. The only difference is that loading code from a .pyc file is faster than parsing and translating a .py file, so the presence of precompiled .pyc files improves the start-up time of Python scripts. If desired, the Lib/compileall.py module can be used to create valid .pyc files for a given set of modules.
Note that the main script executed by Python, even if its filename ends in .py, is not compiled to a .pyc file. It is compiled to bytecode, but the bytecode is not saved to a file. Usually main scripts are quite short, so this doesn't cost much speed.
There are also several programs which make it easier to intermingle Python and C code in various ways to increase performance. See, for example, Psyco, Pyrex, PyInline, Py2Cmod, and Weave.
The details of Python memory management depend on the implementation. The standard C implementation of Python uses reference counting to detect inaccessible objects, and another mechanism to collect reference cycles, periodically executing a cycle detection algorithm which looks for inaccessible cycles and deletes the objects involved. The gc module provides functions to perform a garbage collection, obtain debugging statistics, and tune the collector's parameters.
Jython relies on the Java runtime so the JVM's garbage collector is used. This difference can cause some subtle porting problems if your Python code depends on the behavior of the reference counting implementation.
Sometimes objects get stuck in tracebacks temporarily and hence are not deallocated when you might expect. Clear the tracebacks with:
import sys sys.exc_clear() sys.exc_traceback = sys.last_traceback = None
Tracebacks are used for reporting errors, implementing debuggers and related things. They contain a portion of the program state extracted during the handling of an exception (usually the most recent exception).
In the absence of circularities and tracebacks, Python programs need not explicitly manage memory.
Why doesn't Python use a more traditional garbage collection scheme? For one thing, this is not a C standard feature and hence it's not portable. (Yes, we know about the Boehm GC library. It has bits of assembler code for most common platforms, not for all of them, and although it is mostly transparent, it isn't completely transparent; patches are required to get Python to work with it.)
Traditional GC also becomes a problem when Python is embedded into other applications. While in a standalone Python it's fine to replace the standard malloc() and free() with versions provided by the GC library, an application embedding Python may want to have its own substitute for malloc() and free(), and may not want Python's. Right now, Python works with anything that implements malloc() and free() properly.
In Jython, the following code (which is fine in CPython) will probably run out of file descriptors long before it runs out of memory:
for file in <very long list of files>: f = open(file) c = f.read(1)
Using the current reference counting and destructor scheme, each new assignment to f closes the previous file. Using GC, this is not guaranteed. If you want to write code that will work with any Python implementation, you should explicitly close the file; this will work regardless of GC:
for file in <very long list of files>: f = open(file) c = f.read(1) f.close()
Objects referenced from the global namespaces of Python modules are not always deallocated when Python exits. This may happen if there are circular references. There are also certain bits of memory that are allocated by the C library that are impossible to free (e.g. a tool like Purify will complain about these). Python is, however, aggressive about cleaning up memory on exit and does try to destroy every single object.
If you want to force Python to delete certain things on deallocation use the sys.exitfunc() hook to run a function that will force those deletions.
Lists and tuples, while similar in many respects, are generally used in fundamentally different ways. Tuples can be thought of as being similar to Pascal records or C structs; they're small collections of related data which may be of different types which are operated on as a group. For example, a Cartesian coordinate is appropriately represented as a tuple of two or three numbers.
Lists, on the other hand, are more like arrays in other languages. They tend to hold a varying number of objects all of which have the same type and which are operated on one-by-one. For example, os.listdir('.') returns a list of strings representing the files in the current directory. Functions which operate on this output would generally not break if you added another file or two to the directory.
Tuples are immutable, meaning that once a tuple has been created, you can't replace any of its elements with a new value. Lists are mutable, meaning that you can always change a list's elements. Only immutable elements can be used as dictionary keys, and hence only tuples and not lists can be used as keys.
Python's lists are really variable-length arrays, not Lisp-style linked lists. The implementation uses a contiguous array of references to other objects, and keeps a pointer to this array and the array's length in a list head structure.
This makes indexing a list a[i] an operation whose cost is independent of the size of the list or the value of the index.
When items are appended or inserted, the array of references is resized. Some cleverness is applied to improve the performance of appending items repeatedly; when the array must be grown, some extra space is allocated so the next few times don't require an actual resize.
Python's dictionaries are implemented as resizable hash tables. Compared to B-trees, this gives better performance for lookup (the most common operation by far) under most circumstances, and the implementation is simpler.
Dictionaries work by computing a hash code for each key stored in the dictionary using the hash() built-in function. The hash code varies widely depending on the key; for example, "Python" hashes to -539294296 while "python", a string that differs by a single bit, hashes to 1142331976. The hash code is then used to calculate a location in an internal array where the value will be stored. Assuming that you're storing keys that all have different hash values, this means that dictionaries take constant time -- O(1), in computer science notation -- to retrieve a key. It also means that no sorted order of the keys is maintained, and traversing the array as the .keys() and .items() do will output the dictionary's content in some arbitrary jumbled order.
The hash table implementation of dictionaries uses a hash value calculated from the key value to find the key. If the key were a mutable object, its value could change, and thus its hash could also change. But since whoever changes the key object can't tell that it was being used as a dictionary key, it can't move the entry around in the dictionary. Then, when you try to look up the same object in the dictionary it won't be found because its hash value is different. If you tried to look up the old value it wouldn't be found either, because the value of the object found in that hash bin would be different.
If you want a dictionary indexed with a list, simply convert the list to a tuple first; the function tuple(L) creates a tuple with the same entries as the list L. Tuples are immutable and can therefore be used as dictionary keys.
Some unacceptable solutions that have been proposed:
Hash lists by their address (object ID). This doesn't work because if you construct a new list with the same value it won't be found; e.g.:
d = {[1,2]: '12'} print d[[1,2]]
would raise a KeyError exception because the id of the [1,2] used in the second line differs from that in the first line. In other words, dictionary keys should be compared using ==, not using 'is'.
Make a copy when using a list as a key. This doesn't work because the list, being a mutable object, could contain a reference to itself, and then the copying code would run into an infinite loop.
Allow lists as keys but tell the user not to modify them. This would allow a class of hard-to-track bugs in programs when you forgot or modified a list by accident. It also invalidates an important invariant of dictionaries: every value in d.keys() is usable as a key of the dictionary.
Mark lists as read-only once they are used as a dictionary key. The problem is that it's not just the top-level object that could change its value; you could use a tuple containing a list as a key. Entering anything as a key into a dictionary would require marking all objects reachable from there as read-only -- and again, self-referential objects could cause an infinite loop.
There is a trick to get around this if you need to, but use it at your own risk: You can wrap a mutable structure inside a class instance which has both a __cmp__ and a __hash__ method. You must then make sure that the hash value for all such wrapper objects that reside in a dictionary (or other hash based structure), remain fixed while the object is in the dictionary (or other structure).:
class ListWrapper: def __init__(self, the_list): self.the_list = the_list def __cmp__(self, other): return self.the_list == other.the_list def __hash__(self): l = self.the_list result = 98767 - len(l)*555 for i in range(len(l)): try: result = result + (hash(l[i]) % 9999999) * 1001 + i except: result = (result % 7777777) + i * 333 return result
Note that the hash computation is complicated by the possibility that some members of the list may be unhashable and also by the possibility of arithmetic overflow.
Furthermore it must always be the case that if o1 == o2 (ie o1.__cmp__(o2)==0) then hash(o1)==hash(o2) (ie, o1.__hash__() == o2.__hash__()), regardless of whether the object is in a dictionary or not. If you fail to meet these restrictions dictionaries and other hash based structures will misbehave.
In the case of ListWrapper, whenever the wrapper object is in a dictionary the wrapped list must not change to avoid anomalies. Don't do this unless you are prepared to think hard about the requirements and the consequences of not meeting them correctly. Consider yourself warned.
In situations where performance matters, making a copy of the list just to sort it would be wasteful. Therefore, list.sort() sorts the list in place. In order to remind you of that fact, it does not return the sorted list. This way, you won't be fooled into accidentally overwriting a list when you need a sorted copy but also need to keep the unsorted version around.
In Python 2.4 a new builtin - sorted() - has been added. This function creates a new list from a passed iterable, sorts it and returns it.
As a result, here's the idiom to iterate over the keys of a dictionary in sorted order:
for key in sorted(dict.iterkeys()): ...do whatever with dict[key]...
Versions of Python prior to 2.4 need to use the following idiom:
keys = dict.keys() keys.sort() for key in keys: ...do whatever with dict[key]...
An interface specification for a module as provided by languages such as C++ and Java describes the prototypes for the methods and functions of the module. Many feel that compile-time enforcement of interface specifications help in the construction of large programs. Python does not support interface specifications directly, but many of their advantages can be obtained by an appropriate test discipline for components, which can often be very easily accomplished in Python. There is also a tool, PyChecker, which can be used to find problems due to subclassing.
A good test suite for a module can at once provide a regression test and serve as both a module interface specification and a set of examples. Many Python modules can be run as a script to provide a simple "self test." Even modules which use complex external interfaces can often be tested in isolation using trivial "stub" emulations of the external interface. The doctest and unittest modules or third-party test frameworks can be used to construct exhaustive test suites that exercise every line of code in a module.
An appropriate testing discipline can help build large complex applications in Python as well as having interface specifications would. In fact, it can be better because an interface specification cannot test certain properties of a program. For example, the append() method is expected to add new elements to the end of some internal list; an interface specification cannot test that your append() implementation will actually do this correctly, but it's trivial to check this property in a test suite.
Writing test suites is very helpful, and you might want to design your code with an eye to making it easily tested. One increasingly popular technique, test-directed development, calls for writing parts of the test suite first, before you write any of the actual code. Of course Python allows you to be sloppy and not write test cases at all.
You can use exceptions to provide a "structured goto" that even works across function calls. Many feel that exceptions can conveniently emulate all reasonable uses of the "go" or "goto" constructs of C, Fortran, and other languages. For example:
class label: pass # declare a label try: ... if (condition): raise label() # goto label ... except label: # where to goto pass ...
This doesn't allow you to jump into the middle of a loop, but that's usually considered an abuse of goto anyway. Use sparingly.
This is an implementation limitation, caused by the extremely simple-minded way Python generates bytecode. The try block pushes something on the "block stack" which the continue would have to pop off again. The current code generator doesn't have the data structures around so that continue can generate the right code.
Note that Jython doesn't have this restriction!
More precisely, they can't end with an odd number of backslashes: the unpaired backslash at the end escapes the closing quote character, leaving an unterminated string.
Raw strings were designed to ease creating input for processors (chiefly regular expression engines) that want to do their own backslash escape processing. Such processors consider an unmatched trailing backslash to be an error anyway, so raw strings disallow that. In return, they allow you to pass on the string quote character by escaping it with a backslash. These rules work well when r-strings are used for their intended purpose.
If you're trying to build Windows pathnames, note that all Windows system calls accept forward slashes too:
f = open("/mydir/file.txt") # works fine!
If you're trying to build a pathname for a DOS command, try e.g. one of
dir = r"\this\is\my\dos\dir" "\\" dir = r"\this\is\my\dos\dir\ "[:-1] dir = "\\this\\is\\my\\dos\\dir\\"
Because such a construct would be ambiguous.
Some languages, such as Object Pascal, Delphi, and C++, use static types. So it is possible to know, in an unambiguous way, what member is being assigned in a "with" clause. This is the main point - the compiler always knows the scope of every variable at compile time.
Python uses dynamic types. It is impossible to know in advance which attribute will be referenced at runtime. Member attributes may be added or removed from objects on the fly. This would make it impossible to know, from a simple reading, what attribute is being referenced - a local one, a global one, or a member attribute.
For instance, take the following incomplete snippet:
def foo(a): with a: print x
The snippet assumes that "a" must have a member attribute called "x". However, there is nothing in Python that guarantees that. What should happen if "a" is, let us say, an integer? And if I have a global variable named "x", will it end up being used inside the with block? As you see, the dynamic nature of Python makes such choices much harder.
The primary benefit of "with" and similar language features (reduction of code volume) can, however, easily be achieved in Python by assignment. Instead of:
function(args).dict[index][index].a = 21 function(args).dict[index][index].b = 42 function(args).dict[index][index].c = 63
write this:
ref = function(args).dict[index][index] ref.a = 21 ref.b = 42 ref.c = 63
This also has the side-effect of increasing execution speed because name bindings are resolved at run-time in Python, and the second version only needs to perform the resolution once. If the referenced object does not have a, b and c attributes, of course, the end result is still a run-time exception.
The colon is required primarily to enhance readability (one of the results of the experimental ABC language). Consider this:
if a==b print a
if a==b: print a
Notice how the second one is slightly easier to read. Notice further how a colon sets off the example in the second line of this FAQ answer; it's a standard usage in English.
Another minor reason is that the colon makes it easier for editors with syntax highlighting; they can look for colons to decide when indentation needs to be increased instead of having to do a more elaborate parsing of the program text.


text:
How Sony Got Off Easy With Its 'Settlement' In Class Action Lawsuit By Underpaid Artists
from the class-actions-in-action dept
The case was originally brought back in 2006 by the Allman Brothers and Cheap Trick -- which we wrote about at the time. Both of those bands eventually settled, but by then the case had turned into a class action lawsuit for other Sony Music artists, with the Youngbloods and Elmo Shropshire (who has been involved in some other bizarre copyright lawsuits) taking the place as the named artists in the case. At issue, of course, is whether or not an iTunes transaction is a sale (tiny royalty payment) or a license (much bigger royalty payment). However, the settlement seems pretty paltry. Sony pays out $7.95 million, but as is so often the case in class action lawsuits, the lawyers get $2.65 million of that, leaving $5.3 million for all of the remaining qualified artists. As Digital Music News explains:
Of that $5.3 million, $5 million is reserved for artists who sold at least 28,500 total downloads on iTunes between the inception of iTunes on January 9, 2001 and December 31, 2010 including current class members Youngbloods and Shropshire. Qualifying members would split that $5.3 million pro rata to the number of downloads of their records. However, these two artists may ultimately receive a lot less than splitting the $5 million between themselves because any artist who was signed to Epic, Columbia or Arista Records who sold more than 28,500 is eligible to join the class if they entered into agreements dated between January 1, 1976 and December 31, 2001.It's... something. But considering how much was being dangled in previous estimates, it sure sounds like Sony may end up getting off on the cheap end if this settlement is completed. Oh, and in case you were wondering, Sony probably won't even have to pay out a chunk of this money because if any of the artists haven't recouped yet, this money will merely be "credited" towards their accounts. And considering how the labels aren't exactly known for keeping the best records as to who's actually recouped, there's plenty of room for Sony to keep the money and just claim it's crediting an account that will never surpass the red line.
According to a trusted source there may well be over 100 artists would qualify for membership. The balance of the money, only $300,000, is reserved for all Sony artists with fewer than 28,500 total downloads on iTunes.
The proposed settlement also provides for a prospective 3 percent bump in artists' royalty rates with respect to permanent digital downloads and ringtones sold in the US after January 1, 2011. The 3 percent is against Sony Music Entertainment's gross receipts. This amounts to 3 percent of 70 cents (the amount Sony received for 99 cent downloads) and that is only 2.1 cents.

subset: commoncrawl


text:
these are some sketching of mine, and I to this forum first time, hopeing exchanges Opinions with everybody~hope you like it:>
these are some sketching of mine, and I to this forum first time, hopeing exchanges Opinions with everybody~hope you like it:>
Last edited by george&guo; June 3rd, 2018 at 09:11 AM.
George, welcome to the sketchbook section.
These are fantastic! Thank you for posting! I look forward to seeing more of your work.
Character of the Week :: A weekly character exploration activity.
Other Weekly Activities: COW | EOW | IDW | POW
Sketchbook | Finished Thread
HIRE. ME. i draw stuff.
FOLLOW ME. i blog stuff.
Well not many crits here, I'm love this kind of pencil style. You have inspired me to draw more.
Great work.
Oh shit man, seems that we have another badass sketchbook around here
I really love your style and this loose inkstuff, really great! give us some more, man!
Available for freelance work! contact me via : firstname.lastname@example.com
Follow me on Twitter!!
friend me on Facebook!!!!
Finally Finished
Da sketchbook
Excellent, excellent works. I am defiantely in love. Very inspiring!
Character of the Week :: A weekly character exploration activity.
Other Weekly Activities: COW | EOW | IDW | POW
Sketchbook | Finished Thread
HIRE. ME. i draw stuff.
FOLLOW ME. i blog stuff.
that last one is like AWEEEEEEEEE wow!! keep them coming... fantastic works..
Mainloop- man i must be dyslexic.. cuz i thought you asked how many people are on lsd
Awesome work george, your pencil drawings are excellent.
Cant wait to see some proper colour pieces and stuff.
Keep it up.
PHANDY // Andrew Porter
Concept Artist // Splash Damage
ArtStation Blog Tumblr
Awesome line quality George! Although I must say, as beautiful as the girl in white is, I don't think she could carry that gun as easily as a purse. Look forward to seeing more!
The Zoo Sketchbook
Animal Tutorial
Team RaJa
Chumble spuzz | Kentucky | Skrunchey
great stuff! im totally diggin your style. pls show sum more
my blog
Thanks ererybody likes them,and..~ I specially partial with the line to record some inspiration usually...
holy shit - fantastic
Well George nothing to say really, except...
...PLEASE post more!!!!
Stunning line work, this is such an inspiring thread
drawing it by WACOM
love your style so much man i would love to see like a comic book or something in this kickass style with all those monsters and characters and stuff in it that would rule
Swell! Another guy who's trying to end my "career" as an artist.
Looking at your drawings makes me want to tear the pages off my sketchbook. Thank you very much. You're a pro, and you know that.
just amazing!
One of the most inspirational sketchbooks I have seen in ages. Thank you for posting your work and I hope to see much, much more from you. Excellent lines and values, very good detail.
Two thumbs up!
Sans la colère. Sans la haine. Et sans la pitié.
I always find myself instinctively arrayed on the side of the barbarian, against the powers of organized civilization. -- Robert E. Howard
Writer, illustrator and artist.
Wholy shit~ jaw drops! Crazy man! Got some stars for you! Keep this rolling...
very cool stuff, nice pencil style.
Wow, rad stuff here.
you rule
some beast....
a npc design of a pc game online
a other npc
a flower chost
Holy shit!
You're THAT guy.. I've admired your stuff from afar sir.
My Site :: ::My Sketchbook
Oh My God! One gem after another. Who are you? Are you human? My eyes follow those whimsical lines and end up being upside down . Such a beauty!
Well, treat yourself with respect, you are enormously gifted.
Sveta Dudetta
holy damn i love your work
love to see more
I always hate threads where I don't have anything constuctive to add.
Awsome Stuff


text: Top Producer Seminar Take-Aways February 26, 2013 08:00 PM Tweet Top Producer Seminar hosted agricultural producers from 30 states at the Chicago Hilton in downtown Chicago in late January. The theme "Think Outside the Farm" brought in speakers from outside of agriculture to challenge farmers in how they do business. TAGS: Marketing, Overseas December 18, 2014 By Top Producer Editors Email Off-the-farm thinking provides a unique learning opportunity More than 860 of the nation's largest producers, representing more than 4.5 million acres, gathered in Chicago, Ill., Jan. 30 – Feb. 1 for Farm Journal Media's Top Producer Seminar. This year's theme "Think Outside the Farm" brought in speakers to challenge how farmers do business. "Coming off a terrible drought year, producers need to think outside of their normal mentality to manage risk and improve their operations," says Jeanne Bernick, Top Producer editor and seminar host. "We worked hard to provide high-level information and take-home value." The following pages include highlights from the event. The Perfect Storm and Risk Management Captain Larry Brudnicki, the real-life captain of the Coast Guard ship that performed two dramatic rescues during the worst weather in more than 100 years, which became known as the "The Perfect Storm," shared his story with attendees and talked about his decision-making process. He said risk cannot be avoided. "Some managers believe that all risk is bad," he said. "This approach is similar to the ostrich that sticks its head in the sand." Brudnicki defined risk management as the skillful use of foresight to identify possible adverse future outcomes, and then develop potential viable options to minimize the hazards while maximizing the potential rewards, monitoring the situation and making necessary adjustments to achieve the desired outcome. He recalled someone telling him that a superior sailor is someone who uses his judgment to keep him out of situations that require use of his superior-ship handling skills. Brudnicki said that the principles of risk management are universal and can be applied to any endeavor that requires you to make decisions without guaranteed success. "Throughout your life, you will have to make decisions constantly that will affect your future or the future of your business," he noted. "There is no magic formula to eliminate risk, but you can manage it." Brudnicki shared seven principles to help farmers make the right decisions. The first principle is to identify tasks. "Whenever you begin any new project, it is usually large and complex," he said. "Break the project down into individual tasks." Second, identify hazards. "Look for anything that could go wrong in terms of equipment, environment and personnel," he said. Three, assess risk. "Risk is the potential adverse consequence of each hazard," he added. "Risk equals severity times probability times exposure." The fourth principle is to identify options. Start by looking at all the tasks that have high risk, he said. "Can you perform a different task to accomplish the same goal?" he asked. "If you can, by all means do so. If not, there is not much you can do to change the severity. Is it possible to use different equipment, procedures or personnel so you can reduce the probability or exposure, which will lower the overall risk?" Fifth, evaluate benefit versus risk. The captain said there are three simple but very important criteria for this evaluation process: never accept unacceptable risk, never accept unnecessary risk and never accept a project unless the benefit outweighs the risk. Sixth, execute the plan and lastly, monitor the situation. Risk management is a continuous process, and you are far from being done when you execute you plan, he explained. Watch Land prices Farmland values aren't in a bubble, but prices could still tumble, says a Purdue University ag economist. Like most economists, Brent Gloy, who directs the Center for Commercial Agriculture at Purdue University, does not believe farmland values are in a bubble. But he also thinks there's real danger that values might fall, especially if the economic winds at agriculture's back suddenly change direction. In nominal terms, it doesn't look as if farmland prices have increased as fast as they did during the last bubble, in the 1970s. However, when you take inflation out of the equation, recent increases are "absolutely on par" with what happened in the '70s, Gloy said. "We pay about 30 times cash rent for a farm today," Gloy said. "It's never been that high. It's high in part because people think that cash rents will keep going up, but it's also because interest rates are low." Gloy urged farmers to resist the temptation to buy farmland on credit, which is what led to the farmland bust of the 1980s. He also advised against buying farmland "just because everyone else is doing it." That's the psychology that precipitated both the technology and housing busts. Rising land values make plenty of sense given growing demand from the biofuel industry, foreign nations and growing affluence in developing countries, among other sources. "It all comes back to supply and demand," he said. "Have we seen any increases? You bet we have. Persistent demand growth can substantially increase land values and capital investment." Land investors, particularly the institutional variety, are bullish because they believe world demand will continue to grow, and the productivity of U.S. farms will continue to improve. But he questioned whether the industry has "reached the point where we can't keep up with demand growth through productivity enhancements." Low interest rates are a big part of the land equation. Without today's low interest rates, farm incomes would have to be much higher to support today's land prices. He urged farmers to keep a careful eye on the Federal Reserve. "When the fed takes us out of accommodation, pay attention," Gloy advised. Trade policy is another major wild card. "You don't hear as much about trade policy. But every major bust in ag has corresponded with a bust in exports," he said, recalling the grain embargo after Russia invaded Afghanistan. "Trade policy is something we forget about. Don't lose sight of that as a farmer." If grain demand is boosted by trade, it's supported by domestic ethanol production as well. Noting that corn demand for ethanol production might have peaked, Gloy said that "any downward changes would not be good for farmland values." In the final analysis, Gloy isn't sure what force might take land values in another direction. "It's almost impossible to figure out what will take us out of the cycle," he said. Fertilizer Supply Trends "Make sure your equipment is fully maximized, but not overextended, by the acres you have." Crop nutrients have seen upward price pressure, noted Keith Swanson who leads the fertilizer risk management program for CHS Hedging. Supply is catching up with demand. How do we transition from a short supply to a potential surplus, he asked. Nitrogen manufacturers' margins have pushed global capacity higher, but it's hard to know by how much. Nitrogen has a price allegiance to corn, which allows growers to follow margins, he said. "Take the price of urea and compare that to Chicago corn; track that," he advised. "Over time, it gives us a correlation. To see where the spread is going, we have to look at profits at the acre level to determine margins. Looking at CBOT prices, that's enough risk; then add input cost risk. These compound to make per-acre margins very volatile." Five Considerations Before Buying Land What are the goals for your farming operation? How will your operation evolve or grow in the future? Bret Oelke, University of Minnesota Extension ag business management expert, said farmers have many reasons for growing their business. These include maintaining or improving production proficiency, adding family members to the business, greed, personal challenge and just because they can. The common thought in farm country is growing an operation means adding more acres. Oelke cautioned farmers to think about these points before writing a check or getting a loan for more land. You can grow without adding land. "Growth is important and you should grow 3 to 5% per year or you are standing still or even maybe going backward," Oelke said. Adding land is one way of growing your operation, but he said there are other good ways. He advised farmers to try to maximize yields, use all the resources at your disposal and become a better marketer, all of which can add to overall growth. Consider making land improvements. Drainage, irrigation and tiling to current land have huge payback. Oelke said land investments currently have a higher rate of return than land purchases at "top of market" prices. Know production costs. To make a quick decision to add new land to your portfolio, whether through renting or buying, Oelke said you must know your cost of production. "I can't stress this enough. The lowest-cost grower will always be better to pay more for cash rent." Oelke said your goal should be to have your labor and machinery optimized to your operation's size. He said you should ask yourself: How many acres can you farm with one planter, one combine and the supporting tillage and other equipment you have? Make sure your equipment is fully maximized, but not overextended, by your acres. As competition becomes higher for land to rent, Oelke said communication with your current landlords is vital. "You need to have a plan on what to do if someone offers your landlords more money than you are," he said. Also, make sure your landlords understand your operation and aren't starting to believe rumors or gossip. Oelke explained, in many cases, land owners hear about high prices and assume that farmers sell their entire crop at these high levels." Top Producers share lessons learned This year's Top Producers Luke Brubaker of Brubaker Farms in Lancaster, Pa.; David Nelson of Nelson Family Farms in Fort Dodge, Iowa; and John Carroll of Carroll Brazil Farms in Carthage, Ill., shared lessons they've learned in farming. All three acknowledged that timing has had much to do with their success. Nelson said his timing to return to the farm and work with his father has been a blessing. "The economy was right for me to come back and be profitable with the business," Nelson said. Carroll, who farms in Brazil, referenced Warren Buffett saying that if you can buy dollars for 30¢, buy all you can. "That's kind of what we did," Carroll said. "Now that difference or spread has shrunk." When asked about how they manage risks, Brubaker and Carroll stressed the importance of having good cash flow. "Before I made any purchases, I always made sure the farm could cash flow it," Brubaker said. Carroll explained that in Brazil the lending system is virtually nonexistent. "When you are expanding, you have to buy your inputs, plant a crop and know what your revenue will be," he said. "We would forward sell about 75% of our crop so we knew what we would get." Nelson came at risk management from a different perspective and stressed the importance of peer groups. "Peer groups help you assess your risks," Nelson said. "In order to assess your risks, you have to know what you really have. Compare yourself to peers." Throughout their careers, each has had to deal with and plan for growth. Brubaker, who farms with his two sons, said he belongs to a professional dairy group in Pennsylvania that helps him strategize and figure out what they can do better. Nelson follows a similar philosophy: Make every acre count. "We try to be as profitable on every acre as we can be," Nelson said. "Relationship-building and networking are a part of our strategy." Carroll is focused on growing equity — whether its ginning, hogs or grain. "We benchmark ourselves against our peers and pick the things we do well and expand in those areas," Carroll said. "Markets are not perfectly efficient, but there are places with opportunities." Learn more and watch videos about the 2013 Top Producer of the Year winner and finalists at www.TopProducerSeminar.com. How Does Farming Compare to Other Businesses? Farmers are incredibly self-reliant, but that can also be their downfall. As CEO of the Family Business Institute, Wayne Rivers sees a wide variety of industries from the inside. So, how do farmers and ranchers stack up against manufacturers, car dealers, general contractors or McDonald's franchisees? "Your bond with land is unlike anything we've ever seen," Rivers said, imagining what it must be like to pick up dirt on a family farm that might have been in the hands of great-grandparents. Many manufacturers, by comparison, could care less whether they are making products in Detroit or Birmingham; they'll go where it's cheaper. Rivers said he is equally impressed with the industry's self-reliance. "It completely blows my mind," he said, telling the story of one farmer who needed to run water from a river 200 feet up a bluff. Instead of calling an engineer, this farmer built the system himself. "I can't believe some of the things you guys can do," Rivers said. At the same time, an unwillingness to seek outside help might be an industry "blind spot," Rivers said. The consultant told the story of one farmer who had an extremely high cost of maintenance, yet he refused to spend money on a system that could reduce the time and energy he spent just maintaining. "That same day, he bought two combines," Rivers noted. Human resource management is another area of weakness, Rivers said. Farmers are too focused on the things they love — their crops, equipment and family. "Everything else is a necessary evil," he said, including the "hired man who needs to be treated as part of the team." Rivers criticized farmers for hiring the guy from down the road "because he's a warm body and has a commercial driver's license." Instead, he advised farmers to put together an exhaustive job description, then publicize it near and far. "You want to get 100 applicants, which increases the chance of getting a great person," he said. "Ag can be an industry that's very desirable to be in." Thank You to Our 2013 Sponsors Top Producer sends a huge thank you to its sponsors for making this event possible. Premier sponsors include: AgriGold, AGROTAIN, Asgrow, Dekalb, Apache Sprayers, BASF, Bayer CropScience, Cargill, Challenger, Dow AgroSciences, ESN, Firestone Farm Tires, DuPont Pioneer, RCIS, SFP, Syngenta and Top Third Ag Marketing. Co-sponsors are Advance Trading, Integris, Michelin, Novozymes, Kennedy and Coe LLC, SoybeanPremiums.org and Water Street Solutions. Did you miss the event or want to look at something a speaker showed? Many presentations from Top Producer Seminar are available online. Visit www.agweb.com/topproducer/top_producer_seminar.aspx or click on the QR code at right. For all coverage from Chicago, visit TopProducerSeminar.com. Back to news


text:
We are pleased to announce Visa is now offered as a payment option on the E-payment
site. Also, all one-time payments on the E-payment site will be subject to a $10.00
convenience fee. Sending a check to our lockbox or enrolling in our ACH program,
where the association pulls the payments from your bank account each month, and bill
pay through your bank, continue to be options for making payments without a
convenience fee. Please visit our Payment FAQs page for more specifics.
Community Management specializes in association management
and consulting. Our experience will provide you with expert guidance with the
practices related to common interest developments. Whether your association is big or small we offer the same level of
service and attention to detail. Our mission is to provide individual and
personalized service while working harmoniously with your Association owners and
residents, Board of Directors and service providers.
We've put our member associations online to provide you with some convenience and a wealth of website services and opportunities to share ideas and information;
get news and announcements;
view calendars;
submit service requests and
change your contact information,
access the online resource center
for important association documents and forms; and much more.
We're excited about offering web site association services and
consider it a valuable amentity for the association. Sign-In to access our association's website service now.
If you are new to the website, be sure to complete the Registration Form to receive a password to the private and secured portions of the site.


text:
The simple sweetness of maple sugaring lives on as a centuries-old tradition here in the Poconos, handed down from Native Americans.
The simple sweetness of maple sugaring lives on as a centuries-old tradition here in the Poconos, handed down from Native Americans.
Families and individuals of all ages found their way to the Meesing Sugarbush in Marshalls Creek on March 2 as more than 350 people came throughout the day for the annual Public Maple Sugaring Day, to learn the history of maple syrup from educators with the Monroe County Environmental Education Center.
According to legend, Native Americans discovered sweet sap by sucking on icicles dripping from trees. They shared with colonists their ways of collecting and boiling down the sap into syrup.
"The early settlers realized they could clean out the soft centers of sumac branches to make tubes, spiles, for collecting the sap," explained educator Jennifer Rituper. "The Indians kept it as solid sugar; the settlers kept it as a liquid in barrels."
It takes a barrel full of the clear sap that is generally regarded as about 30 gallons — which tastes like, and has the consistency of, slightly sweetened water — to make one gallon of pure maple syrup.
"Sugar boils at seven degrees above the boiling temperature of water," said Karen Boyle, environmental educator. "At 219 degrees, it is syrup."
Centuries ago, when the settlers cooked it over an open fire, the mother would test the syrup by dripping a little onto the snow, to see if it was hot enough to melt through, Rutiper said. The hardworking kids — it was they who canvassed the woods to find maple trees, and then used yokes to transport heavy buckets of sap — looked forward to the frosty treats, called jack wax.
Modern maple sugaring methods use plastic spiles and tubing networked to a central collection tub. The narrower plastic spiles require a much smaller hole in the tree, which promotes better healing for the tree after tapping.
"This year, we added a few more trees and extended our tube lines which improved the amount of sap we can collect," said educator Roger Spotts. "Last year we made right around 30 gallons. Two years ago, because of the weather, we only made 19. If we get 30 to 40 gallons, that's a good average year for us."
MCEEC has been tapping trees at Meesing for about 36 years. There are about 250 trees to be tapped, both sugar and red maples.
Tapping is done in late winter when the sap begins to run slowly; once the weather warms and the sap begins to run fast, it becomes bitter from excess tanning in the trees and the syrup is no longer palatable.
"I've been here before with a third-grade field trip," said Kyle Gray, a seventh-grader now at J.T. Lambert Intermediate. "I learned how the settlers hollowed out soft branches and sharpened the ends to stick in the tree to use as spiles for getting the sap into the buckets."
On the Web: mcconservation.org.


text: New Massey Ferguson 5600 Utility Tractors January 31, 2013 11:47 AM Tweet TAGS: Marketing, Overseas December 18, 2014 By Margy Eckelkamp Director of Content Development, Machinery Pete Email With 70 and 75 PTO hp, respectively, the MF5609 and MF5610 are outfitted with AGCO Power engines, hydraulic capacity and a visibly updated cab all designed for loader work, hay production and general farm chores. The tractors are powered by AGCO Power three-cylinder engines with electronic engine controls that meet Tier 4 Interim emissions standards. These engines powering the 5600 Series tractors have four valves per cylinder, for improved airflow through the engine to enhance fuel/air mixing, meaning lower annual service costs. Wet replaceable cylinder liners with mid-supports also keep service costs down by ensuring correct engine cooling. In addition, the engines are equipped with a SisuTronic EEM4 electronic engine management system that monitors and manages every aspect of engine operation, including fuel flow and injection timing to keep the engine running as efficiently as possible. A Bosch fuel pump and single-pressure vessel deliver fuel to each cylinder for exceptional fuel/air mixing and more complete combustion, keeping engines running smoother, longer. The 5600 Series use the Dyna-4 transmission with 16 forward and 16 reverse, however new on the 5600 series is a standard 16x16 gearbox with speed matching and the traditional "T"-handle gear shift. An AUTO-DRIVE function is also available as an upgrade option. New to the Dyna-4 transmission is AUTO-N, allowing the gearbox to go into neutral when the operator engages both brake pedals. This feature makes loader work faster and more convenient by eliminating the use of a hand lever or clutch pedal. An open-center hydraulic system features a standard flow rate of 11 gallons per minute (gpm) to the rear three-point linkage and 15 gpm to remote valves. An optional Twin Flow system combines the flow from both pumps, providing 26 gpm to remote hydraulic circuits. The MF5609 and MF5610 have identical-sized cabs to the Massey Ferguson 7600 Series and use a six-post design. The front dash of the cab is modeled after that of the 8600 Series, offering a narrow cross-section to improve forward visibility. The 5600 Series also comes with an optional Visio Roof, for additional visibility during loader work. For more information www.masseyferguson.us. Back to news


text:
My Letter to HIV: A Letter From Joshua Rosario King
April 26, 2012
Dear HIV,
At first I was scared of you, then I didn't know what to do with you, I found myself lost in you, but now I find comfort that you have no power over me and that you live with me not the other way around. I take joy in knowing I have better control over you and you can't hurt me unless I let you. No no HIV not me; you is not getting this one. HIV, I not only find joy in knowing you live with me. I am happier because I know I am gonna live a long healthy prosperous life. I exercise, eat right; take better care of me and my body. Why you ask? Because I let you in but could never let you defeat me. I won this battle and I plan on winner the war but outliving you HIV. So all I have to say is thank you HIV for inspiring me to take better care of my self so I can be around to be the example to others and teach them what you taught me. I look back at my trials and tribulations and I am very thankful for them because without them I wouldn't be who I am today. So I am here to once again say thank you HIV. I am thankful to say I have an international HIV/AIDS ministry called (VISION) reaching out to those who are affected and infected. Thank you HIV thank you. "The joy of the Lord is my strength".
Joshua Rosario King
This article was provided by "Write a Letter to HIV" Campaign at TheBody.com.
Add Your Comment:
(Please note: Your name and comment will be public, and may even show up in
Internet search results. Be careful when providing personal information! Before
adding your comment, please read TheBody.com's Comment Policy.)


text:
TrapStreet's Ma2g (Feat. Nooch & M.O.E) - Black Hooded Up [Unsigned Hype]
"The third video in a series from TrapStreet's own Ma2g. Download Trapstreet mixtapes for free at www.trapstreet.com ... Get On Trap! Produced by BpZy/Beat Fanatik for D.O.E. Llc Directed by Mar/M-Visions" - T
Please click the "Report" button below if the video on this page is not working properly.
Comments will only be displayed by verified emails. No Spamming or Racism.


text:
The heating, ventilation and air conditioning (HVAC) service sector is an $82 billion industry. As it continues to grow, there's no shortage of software products on the market to support it.
Whether you have a one-man shop, small business or large enterprise, HVAC field service management software is critical. These systems organize technicians' daily tasks, customer data and more and help keep appointments on schedule.
However, since there are many product options, it might be difficult to know which one is best for your business. To help, we put together this guide.
Here's what we'll cover:
What Is HVAC Service Software?
Common Functionality of HVAC Service Software
Potential Benefits of Using HVAC Service Software
How HVAC Service Software Is Priced
Integration With Other Applications
HVAC service software is a type of field service management technology built specifically to handle the workflows and requirements of HVAC contractors. Buyers looking for HVAC dispatch software or HVAC scheduling software will typically find an integrated HVAC service software system beneficial. These systems can track almost any type of data that field technicians might need to help them work more efficiently, such as:
Since HVAC service software is intended for use in the field, most applications are accessible on mobile phones, laptops and tablets. That way, technicians can access customer details and work history, keep detailed notes, accept payments and capture photos on-site—all without having to call dispatch for information or update records when in the office.
Job schedule and status on iOS app for FieldAware
HVAC products typically support appointment scheduling, invoice creation and customer data storage. Beyond that, some systems also track HVAC equipment information, manage the business' parts and supply inventory and facilitate customer communication.
Here's a detailed description of this functionality:
|Scheduling and routing
|Lets field managers generate service schedules and routes based on the availability of contractors and other resources.
|Customer management
|Basic customer management tools let companies store and view customer account details, payment and service history.
|Invoicing and payments
|Allows technicians to create work invoices and automate customer payments upon completion of service while on site.
|Equipment tracking
|Helps companies keep track of HVAC equipment details, such as make, model, serial number, warranty data, manufacturer and more.
|Inventory management
|Lets users maintain inventory supply by tracking what items are used and sold and restocking when levels are low.
|Customer portal
|Service customers can view available appointment windows, submit service requests, pay invoices and check expected arrival times.
Service scheduling dashboard for ServiceTrade
Service contractors who figure out how to effectively incorporate this software into their workflows can realize many benefits, including:
Fewer scheduling errors. Software Advice found nearly 67 percent of field service customers (not HVAC-specific) would not re-hire a company if a technician was up to 60 minutes late. Clearly, it's important to prioritize punctuality. HVAC service software's scheduling capabilities can give dispatchers a complete view of contractor schedules, location and availability to set appointment times contractors can keep.
Scheduling and dispatch board daily view for WinTac
Reduced double data-entry. The majority of HVAC service applications are built for use in the field. Therefore, technicians can create invoices, update records, take notes, track their time and more while on the job. This is much more convenient (and accurate) than having to create hand-written records that are entered into a system back in the office.
Increased overall efficiency. Service management products for HVAC companies automate many tasks, including: work orders generation, time tracking, scheduling, invoicing and customer management. When done manually, such tasks require many hours each day, so automating them can eliminate a lot of administrative work.
The cost of field service software for HVAC contractors generally increases as the depth of functionality increases.
Products on the lower end of the cost scale typically include only the most essential functionality, such as scheduling and basic invoicing and customer management. On the higher end, products have a more robust feature set—customer portals, inventory management and GPS fleet tracking capabilities, for example.
HVAC software's price is also dependent on the number of people who will use the product. Some vendors charge a one-time or recurring fee based on the number of users. For example, a single user is charged a license fee; then, as the number of users who will need to access the system goes up, the per-user license cost goes down.
Other vendors charge a fixed one-time or recurring fee, which stays the same whether one or 50 users access the application.
The difference in per-user versus fixed-rate pricing models is especially important for businesses with many technicians.
For some businesses, especially large enterprises, integrating HVAC service software with other business applications is important.
Common integrations include:
Accounting software. HVAC business owners who integrate their field service software with an accounting solution can save themselves from having to manually transfer invoice and billing data from one application to another.
Customer relationship management (CRM) software. Companies with sales and customer support teams often require advanced interaction tracking and multi-channel marketing automation to effectively nurture prospective and existing customers. Integration with a CRM application can lead to more insights to help those teams upsell and meet customer expectations.
Our service is simple and 100% free to customers like you because software vendors pay us when we connect them with quality leads. You save time and get great advice. Vendors get great referrals. It's a win for everyone!


text:
My political career started in the early 1960s, when I was a young reporter and then a speechwriter for political candidates. My hometown of Long Beach was one of only two Democratic areas on all of Long Island. Once you ventured outside the city, it was all Republican in every town, village and hamlet. In my first of 13 campaigns for the State Assembly, without Long Beach Democrats my margin of victory would have been small, or I would have lost.
Time goes by quickly, and a snapshot of our county shows that the vaunted Republican machine is facing its strongest challenge in over 100 years. Enrollment numbers have changed drastically. According to the state Board of Elections, Nassau has 345,787 Democrats and 321,852 Republicans. Once upon a time, any new residents of the county were encouraged to register Republican if they wanted their streets snow-plowed in the winter. Those days are gone.
More and more New York City dwellers with no political affiliation are crossing the Queens-Nassau border. Some don't want to be associated with any political party, so they leave their forms blank. That accounts for the fact that there are over 200,000 registered voters with no party enrollment. But over the past 10 years, the Democratic Party has attracted more voters than the Republicans, and their number is growing.
It's true that, year after year, the Nassau Republican Party has achieved numerous successes at the ballot box. Other than judicial nominations, Republican candidates for office have done quite well. But 2017 is a different year, and the tea leaves show that there's much for the party to worry about. Indictments of Nassau and town officials contributed last year to the loss of a State Senate seat, and this year there are many more contested positions, which means there's a need for tons of money and lots of foot soldiers.
With Republican County Executive Ed Mangano leaving office, there are two newcomers seeking that powerful position. Former State Sen. Jack Martins is the Republican candidate, being challenged by Laura Curran, a Democratic county legislator. Money won't be an issue for the Democratic ticket, with well over $1 million in hand and money coming in at a rapid pace. No doubt the Republicans will raise significant money as well, but there's a dark cloud over the GOP campaign that doesn't help.
Beyond the troubles in the county, the two towns run by Republicans are feeling their own angst. Oyster Bay, which is as Republican as any enclave on Long Island, will see a bitter and close contest for town supervisor in November. Former State Assemblyman Joseph Saladino is the Republican candidate, and he's being challenged by Marc Herman. The indictments of former Supervisor John Venditto hurt last year, and could inflict more damage this year.
Once upon a time, Oyster Bay was as politically predictable as Big Ben's chimes in London. That is no longer the case. With many new voters in town and a lot of political unrest, the supervisor race will be a tossup, with the polls currently favoring Herman. In conversations with Oyster Bay residents of both parties, there is a undercurrent of unhappiness with the Republican Party, no doubt caused by some of the dysfunction in Washington.
The Town of Hempstead, traditionally Republican, is facing internal upheaval among its own rank and file. Two Town Board members, Erin King Sweeney and Bruce Blakeman, are challenging the actions of Town Supervisor Tony Santino. That bitterness has flared into the open at Town Board meetings, and is creating a climate of uncertainty with the party regulars. There's no way to heal that rift, and it could create some stress on Election Day. There's not much doubt that the Republicans will hold on in November, but it may not be the usual landslide.
What was once unthinkable — the idea of Democratic victories in Nassau County — is now close to becoming a reality. The Republican Party is still very much alive, and knows how to rally the troops on Election Day, but this year that might not be enough to stop the new energy that is helping the Democrats.
Jerry Kremer was a state assemblyman for 23 years, and chaired the Assembly's Ways and Means Committee for 12 years. He now heads Empire Government Strategies, a business development and legislative strategy firm. Comments about this column? email@example.com.


text:
Difference between revisions of "Jagdalpur"
Revision as of 12:50, 24 July 2007
Jagdalpur is a city in Bastar district in the Indian state of Chhattisgarh.
Get in
From Visakhapatnam, catch the 1 Vishakapatnam - Kirandul Passenger (1VK) having Reserved First Class & Sleeper Class accomodation. 1 VK departs Vishakapatnam at around 06:45 am and reaches Jagdalpur by around 05:30 pm
From Hyderabad, you have to reach Bhadrachalam first and then drive down close to 250 Kms on the single -laned NH 212, via Konta & Sukma to reach Jagdalpur. Road conditions are bad,and be prepared for frequent checks by the law enforcement authorities. Your vehicle of choice for a trip to Jagdalpur should ideally be a vehicle having a high ground clearance, and SUVs like the TATA Safari & Ford Endeavour fit the bill perfectly.
From Raipur (Capital of Chhattisgarh state), the road to Jagdalpur is good enough. You have regular overnight non-a/c sleeper buses running between Raipur/Bilaspur & Jagdalpur.
Get around
Check out the Anthropological museum (Located about 3 Kms from the city centre - closed on Sundays); there is also a big lake within Jagdalpur, with boating facilities. Take a walk down the Sanjay market area. No public transport in Jagdalpur; you can hire cycle-rickshaws though.
There is another temple (dedicated to Goddess Danteshwari) located at Dantewada, about 60 Kms from Jagdalpur, on the way to Bailadila.
Mahua - the traditional Bastar drink. Have it strong or mix it with water or soft drinks.
Get out
If not on your own conveyance,and intend to get to Raipur, catch one of those numerous sleeper non-a/c buses to Raipur.
If you intend to go to Vishakapatnam, catch the return 2VK passenger that arrives at Jagdalpur at around 09:30 am (Daily service)
If you intend to go to Hyderabad/Vijayawada, start early, catch the NH 212 to Bhadrachalam, and onwards to Hyderabad/Vijayawada.
BEWARE OF NH-16 TOWARDS NIZAMABAD - Never even think of going west, towards Nizamabad (In Andhra Pradesh). Maps show the existance of NH16, linking Jagdalpur & Nizamabad via Gidam,Bijapur,Madded & Bhopalapatnam, but in reality, the road (NH-16) starts gettting bad to worse from Bijapur onwards, and abruptly comes to a halt at Bhopalapatnam. Lack of a bridge across the Indrawati near Bhopalapatnam is the main culprit.
So, if you are planning to get to Hyderabad via Bhopalapatnam & Warangal (NH - 202) - don't even think about it!


text:
SAC Braces for $1 Billion in Possible Withdrawals
Hedge-fund group SAC Capital Advisors has told employees and business partners it is bracing for client withdrawals of at least $1 billion this year, amid intense regulatory scrutiny of alleged insider trading. Dana Cimilluca reports on Markets Hub. Photo: AP.
This transcript has been automatically generated and may not be 100% accurate.
... I ... what a ... Wall Street Journal ... A C Capital the successful hedge fund run by Steve telling ... him for a scene from the axis find ... clients taking money out of the firm ... is all these insider trading for aam probes swirl around the company ... morning Evelyn welcome to markets of mine Paul vignette which they missed the maximum that goes with us from London he wrote the story tail on a couple of the reporters ... did I know ... how surprising is this given everything has been going on with the CC ... the investors are a little jittery ... price cause it's not it's not surprising aam at the same time I don't think we we ever had of ... sort of concrete sense of what the magnitude could be and what we're hearing is that internally there they're bracing for something ... aam substantially no number we put in the story was up ... of ... the Nov points to over billion ... at least a billion is always sad ... so aam ... you know I think the big question is the first of all that important but up its early days this this is a moving target things could change ... but of course wanting a keeper mind is that aam ... meaning that number side which is probably manageable for them sometimes these things can feed on themselves so that number could actually ultimately lead to more redemptions ... been working with the reason is ... the client and sales just don't want headline risk for the reasons they really don't believe the company more ... it's almost inconsequential because as you say ... it all the clients do with those plans are doing ... does it does feed on itself ... is it that there's two points here you rightly point out ... aam you know there's the sheriff effectively just like a vicious circle but also there is this headline risk factor you know ... investors see a hedge fund Vestas another so beleaguered nowadays with all the negative the barrage of negative headlines over so many years now it seems ... why would you wanna get no way that you can avoid it even if it if it is the fun that you know ... has done you know you've done well by over ... over a number of years ... that's the that's the right to the SEC's done ... phenomenal for their clients ... on now in terms of ... their total assets in the way those assets are structured ... this would not be a crippling blow even if the was a billion dollar write ... aam correct I mean the bulk of the um ... funds that the firm belongs to ... Steve Cohen the founder of the firm in his partners something like ... eight or nine Billy and ... so the outside money only announced a ... six billion or so ... aam one important point though is that aam ... the firm largely as I understand it ... is Iran that using aam management fees from the outside money so as that starts to evaporate ... aam ... something is going to need to make up for that you know whether it's ... you know Cohen reaching into his own pocket or them funny some of the way that come up the funds to help them the fact we keep the lights on and pay people sellers of things like that the Muslim Khan the money would come out all at once for a ... now that's right these days hedge funds most of them have gates is what they're called to ... be don't protect themselves against situations where there's a rush to the exit that forces them to sell you know their existing holdings ... you know strictly a loss what they've done is they've they've sent investors if you want your money out ... there you tells now I buy fabric fifteen and will give it to you over the course of the year twenty five percent each quarter between March and December ... permanent financing comes up ... with a pretty firm pretty brave brave face on this whole thing ... doing business is usually the closed an office in Chicago ... when it come out they have a couple of meetings with investors talking about ... the scandal probes ... I WellPoint though does this start to really Khona squeeze them ... for what it is important why now you know they've they've said you know number one that they're cooperating with the DEA ... investigation that number to you know he ... and a haven't anything wrong ... aam ... but top yes I mean Tom ... the the it's it's it's difficult to operate in an environment where you're beleaguered is much is they aren't and afterward we made this plain story ... it seems very clear that the feds are are after this from a really wanna make a case against him ... and Dom it Stifel top Renault and the headlines for iTunes similar Finland and appreciated thank you ...