Things learned about VirtualBox Space Management

 Back around May of 2019 I decided to by a 1 TB SSD just for my virtual machines. Within a year it was already full. Why?

Lessons Learned:

1. Just because you can allocate a lot of HDD space doesn't mean you should.   

    One of my mistakes was dedicating 250 GB of memory just to one instance of Ubuntu!

2. Snapshots add up

    I thought snapshots were little things. Little did I realize that when you take several, they really start to add up. Learn proper best practices for deleting old snapshots. They should be the first place you go to free up Disk Space.

3. Make your snapshots descriptive 

Speaking of, try adding a description to your snapshots.  So many decisions on whether or not to delete a snapshot can be alleviated if you simply labeling WHY this snapshot exists.

4. Have a plan for how much space an Virtual Machine will need

Back then, I was going with the "better to have too much than too little" philosophy, especially as I'd experienced how much of a pain in the neck incrementing a VHD can be. 

5. Have a purpose for each virtual machine, and don't be afraid to delete once it's served

Generally, having isolated machines to practice online tutorials was the purpose behind my virtual machines. I was experimental, but with experience it's clear that one should get rid of machines that just plain aren't in use. Not only does it save space, but it saves you from later confusion.

VirtualBox: Resizing Disks

 I once found myself needing to increase the size of a virtualbox disk. To that end, I found this guide helpful. Hence, making a note here:

Quick Tips:

1. This will only work on Dynamically Allocated Disks. It will NOT work on fixed disks.

2. Put .\ in front of the command vboxmanage.exe

Sample Command:

.\vboxmanage.exe modifymedium "C:\Users\David\VirtualBox VMs\Ubuntu2019\VirtSSD.vhd" --resize 30999

Python - Creating Module Packages

Intent

Beyond importing someone else's packages, sometimes it helps to make your own. This will assist in the understanding of how to do so.

I. It helps to have the pep8 compliance package to test.

py -3 -m pip install pytest
py -3 -m pip install pytest-pep8

Next step, make sure your module is pip complaint

1. cd to your module and run…
2. py.test --pep8 vsearch.py

Common Errors Found

1. Not having two blank lines between each function
2. Not having a white space following a colon
3. Using tabs to indent. It prefers 4     blank   manual    lines

Note the ^ will mark where in the code it believes things are out of compliance.

II. Next a setup.py and a README.txt file are required

 

Creating setup.py

 

Textbook example:

from setuptools import setup

setup(name='vsearch', version='1.01', description='The Head First Python Search Tools', author='HF Python 2e', author_email='hfpy2e@gmail.com', url='headfirstlabs.com', py_modules=['vsearch'],)

Creating README.txt

Just put in whatever you want. So long as the README exists.

III. Run setup.py as the setup distribution

In the command line run as follows: 

py -3 setup.py sdist

IV. Install your new module from within it's distribution

Example:

py -3 -m pip install [moduleName]-1.0.zip

V. Now you can run your module. Don't forget to run it as something, or you'll have to call it by what it is. Have fun! :)

Python Basic Data Structures and Common Commands Cheatsheet

Lists	[]	list	append, extend, pop, index
Tuples (immutable)	() or {},	tuple
Sets	{'',}
Dictionary	{}	dict

List | Common Commands:

Append | For adding a single element. If you give it a list, it'll add a list of a list

Extend | for merging a lot of elements

Clear | for clearing the element

Index | for searching the position of an item, first occurrence.

Remove | for removing a specific item, first occurrence

pop | for removing a single item from at a INDEX position (AND returning it if need be). 

Copy | For creating a new object. Anyway else will just reference the old object

Reverse | Flips things over

Count | Built in Frequency Counter

Examples

Iterating in Python Sampler

for i in [1, 2, 3]:

print (i)

for ch in "Yay!":

print(ch)

for num in range(5):

print('David is good at this!')

help(range)

phrase="Don't Panic!"

All the Letters

phrase

Every Third Letter up to index location 10

phrase[0:10:3]

All letters up to but not including the 10th

phrase[:10]

Only the first three letters

phrase[3:]

Every Second Letter

phrase[::2]

How to count backwards 1

backwords = phrase[::-1}

''.join(backwords)

>>> phrase[::-1]

"!cinap t'noD"

How to count backwards 2

>>> phrase = "The Sky is Blue"

>>> words = phrase.split(' ')

>>> words

['The', 'Sky', 'is', 'Blue']

>>> words[::-1]

['Blue', 'is', 'Sky', 'The']

Spring Core Containers and Dependency Injection

Java classes should be as independent as possible from each other.

• To decouple classes from one another, dependencies should be injected through Constructors and Setters.
• Classes should not configure themselves. IoC uses dependency injection to: 
• Configure a class correctlyi from outside the class
• Wire services or components.
• Piecing together all the beans in the Spring Container is called Wiring.
• This can most commonly be don through xml.
• Various BeanFactories and ApplicationContext objects that support wiring include:
• XMLBeanFactory
• ClassPathXMLApplicationContext
• FileSystemXMLApplicationContext
• XMLWebApplicationContext

Spring Fundamentals

Originally developed to fight against low level maintenance, Spring framework functionality can be used in any JavaEE server and most of it is also adaptable to non-manage frameworks.

Most JavaEE applications are complex and require a lot of effort to develop.

Spring's BeanFactory enables configuration options from XML by providing dependencies when required, automatically.

Spring is composed of 7 key components. These modules can be chosen freely as needed.

1. Spring Core - separates configuration from dependencies
• Prime Components: BeanFactory; Application contexts.
• Bean Factory: Provides support for dependency injection.
• Application Contexts: provides application framework services.
2. Spring Context
• A configuration file that provides contextual information to the Spring Framework. JNDI, EJB, email, scheduling and internalization services.
3. Spring AOP
• Integrates Aspect Oriented Programming through its configuration management feature, providing transaction management services for objects in any Spring-based application.
4. Spring DAO
• Data Access Object abstraction layer offers a meaningful hierarchy for the managing of exceptions and error messages. This greatly reduces the amount of code you need to write, such as opening and closing connections.
5. Spring ORM
• Object Relational Map -Object oriented programs and relational databases tend to speak completely different languages. This bridges that gap. This provides support to several ORM solutions, including Hibernate, JDO, JPA, and others.
6. Spring Web Module
• Builds on top of the application context module, to provide contexts for Web-based applications. The Web module
7. Spring MVC
• A full featured MVC implementation for building Web-applications. Highly configurable via strategy interfaces. It accommodates numerous view technologies including JSP, Velocity, Tile, and so on.