MS Small Basic: ¿Qué es una detección de colisiones? (código)


colision1

En general, la detección de colisiones trata de cómo determinar la intersección de dos objetos en movimiento.

La detección de colisiones en los juegos necesita de los siguientes pasos:

  •  Selección de dos objetos para la prueba de colisión.
  •  Comprobación de si se produjo una colisión entre los objetos identificados o no.
  • Se dice que dos objetos chocan cuando entran en contacto el uno con el otro. Los objetos pueden moverse después del choque o pueden detenerse, dependiendo del tipo de colisión.

La detección de colisión es un aspecto básico de los juego de dos y tres dimensiones. Los algoritmos ayudan a detectar la colisión. La mayoría de juegos utilizan detección de colisiones una vez que esta se ha producido.

El siguiente juego contiene dos objetos: la tortuga y el objetivo. El jugador tiene que hacer que la tortuga golpee el objetivo, introduciento para ello el ángulo correcto y la distancia.

Código:

  1. ‘ Copyright (c) Microsoft Corporation.  Todos los derechos reservados.
  2. GraphicsWindow.Hide()
  3. gw = 620
  4. gh = 450
  5. GraphicsWindow.BackgroundColor = “LightBlue”
  6. GraphicsWindow.CanResize = “False”
  7. GraphicsWindow.Width = gw
  8. GraphicsWindow.Height = gh
  9. GraphicsWindow.Top = ( Desktop.Height – gh ) / 2
  10. GraphicsWindow.Left = ( Desktop.Width – gw ) / 2
  11. GraphicsWindow.Title = “Dar en el blanco”
  12. GraphicsWindow.Show()
  13. Turtle.Hide()
  14. rx = 40
  15. ry = 20
  16. tortugaX = 315
  17. tortugaY = 300
  18. ancho = 550
  19. alto = 390
  20. CuadroPuntuaciónX = 400
  21. TeclaEntrar = “Return”
  22. diana = 10
  23. vidas = 3
  24. puntuación = 0
  25. GraphicsWindow.FontSize = 30
  26. GraphicsWindow.DrawText(10, 200, “¡Pulse ENTRAR para comenzar el juego!”)
  27. GraphicsWindow.KeyDown = AlPresionar
  28. Sub AlPresionar
  29. entrar = entrar + 1
  30. If GraphicsWindow.LastKey = TeclaEntrar And entrar = 1 Then
  31. GraphicsWindow.Clear()
  32. GraphicsWindow.FontSize = 12
  33. Interfaz()
  34. MoverFigura()
  35. MostrarPuntuación()
  36. Controls.ButtonClicked
    = Disparar
  37. EndIf 
  38. EndSub
  39. Sub Disparar
  40. ángulo = Math.Round(Controls.GetTextBoxText(ángulotexto))
  41. distancia = Math.Round(Controls.GetTextBoxText(distanciatexto))
  42. presionado = Controls.GetButtonCaption(Controls.LastClickedButton)
  43. If presionado = “Disparar” Then
  44. GraphicsWindow.PenWidth = 0
  45. Turtle.Angle = ángulo
  46. Turtle.Move(distancia)
  47. If Turtle.x > x and Turtle.x < x + 93 and Turtle.y > y and Turtle.y < y + 96 Then
  48. Shapes.HideShape(diana)
  49. puntuación = puntuación + 10
  50. MostrarPuntuación()
  51. Program.Delay(500)
  52. If diana = puntuación Then
    1. TerminarJuego()
    2. EndIf
    3. Controls.SetTextBoxText(ángulotexto, “”)
    4. Controls.SetTextBoxText(distanciatexto, “”)
    5. MoverFigura()
    6. Else
    7. Program.Delay(1000)
    8. If vidas > 1 Then
      1. GraphicsWindow.ShowMessage(“Haga clic en Aceptar para continuar el juego”,”Reintentar”)
      2. presionado = “Reintentar”
      3. Else     
        1. TerminarJuego()
        2. EndIf   
        3. EndIf        
        4. EndIf 
  53. If presionado = “Reintentar” Then   
  54. vidas = vidas – 1
  55. If puntuación >= 10 Then
  56. puntuación = puntuación – 5
  57. EndIf   
  58. MostrarPuntuación()
  59. Controls.SetTextBoxText(ángulotexto, “”)
  60. Controls.SetTextBoxText(distanciatexto, “”)
  61. MoverFigura()
  62. If vidas < 1 Then
  63. TerminarJuego()
  64. EndIf   
  65. EndIf
  66. EndSub
  67. Sub Interfaz
  68. imagen = Program.Directory + “\dibujo.png”
  69. GraphicsWindow.DrawRectangle(rx, ry, ancho, alto)
  70. diana = Shapes.AddImage(imagen)
  71. GraphicsWindow.BrushColor = “Black”
  72. Shapes.Move(diana, 100, 50)
  73. Turtle.Show()
  74. Turtle.X = tortugaX
  75. Turtle.y = tortugaY
  76. Turtle.Angle = 0
  77. GraphicsWindow.DrawText(rx + 5, alto – 10, “Ángulo:”)
  78. ángulotexto = Controls.AddTextBox(tortugaX – 205, tortugaY + 70)
  79. Controls.SetSize(ángulotexto, 40, 30)
  80. GraphicsWindow.DrawText(rx + 140, alto – 10, “Distancia:”)
  81. distanciatexto = Controls.AddTextBox(tortugaX – 60, tortugaY + 70)
  82. Controls.SetSize(distanciatexto, 40, 30)
  83. firebutton = Controls.AddButton(“Disparar”, tortugaX + 20, tortugaY + 70)
  84. Controls.SetSize(firebutton, 80, 30)
  85. Endsub
  86. Sub MoverFigura
  87. Shapes.ShowShape(diana)
  88. Turtle.x = tortugaX
  89. Turtle.Y = tortugaY
  90. Turtle.Angle = 0
  91. x = Math.GetRandomNumber(450)
  92. y = Math.GetRandomNumber(80)
  93. If x <= 40 Then
  94. x = 40
  95. Shapes.Animate(diana, x, y, 1000)
  96. ElseIf y <= 20 Then
  97. y = 20
  98. Shapes.Animate(diana, x, y, 1000)
  99. Else 
  100. Shapes.Animate(diana, x, y, 1000)
  101. EndIf
  102. EndSub
  103. Sub TerminarJuego
  104. GraphicsWindow.ShowMessage(“Puntuación: ” + puntuación, “FIN”)
  105. Program.End()
  106. EndSub
  107. Sub MostrarPuntuación
  108. GraphicsWindow.FontSize = 14
  109. GraphicsWindow.BrushColor = “Gray”
  110. GraphicsWindow.FillRectangle(CuadroPuntuaciónX + 50, CuadroPuntuaciónX – 65, 135, 70)
  111. GraphicsWindow.BrushColor = “White”
  112. GraphicsWindow.DrawText(CuadroPuntuaciónX + 60, CuadroPuntuaciónX – 55, “Puntuación: “)
  113. GraphicsWindow.DrawText(CuadroPuntuaciónX + 150, CuadroPuntuaciónX – 55, puntuación)
  114. GraphicsWindow.DrawText(CuadroPuntuaciónX + 60, CuadroPuntuaciónX – 20, “Vidas: “)
  115. GraphicsWindow.DrawText(CuadroPuntuaciónX + 110, CuadroPuntuaciónX – 20, vidas)
  116. EndSub

Objeto Program


program

Cuando se crean programas y se trabaja con varios objetos y operaciones que ofrece en el entorno .NET, es posible que desee controlar la ejecución de su programa. Puede utilizar el objeto Program para manipular la forma en que su programa se ejecuta

Puede controlar la ejecución de un programa mediante el objeto Program en Small Basic. Observe el ejemplo en pantalla.

  1. Primero, se usa la operación Directory para      mostrar el directorio actual del programa de ejecución. Para mostrar la      ruta al directorio, use el objeto TextWindow con la operación WriteLine.
  2. A continuación, para retrasar la ejecución      del programa por cinco segundos, se usa la operación Delay y se      define el parámetro de tiempo en milisegundos.
  3. La declaración Program.End() hace      que el programa termine.

Revise los resultados del programa haciendo clic en el botón Ejecutar de la barra de herramientas o presionando la tecla F5. La ventana de texto muestra el directorio del programa y, después de un retraso de cinco segundos, el programa termina.

TextWindow.WriteLine(“Carpeta del programa ” + Program.Directory)

TextWindow.WriteLine(“Este programa se ejecuta durante 5 segundos.”)

Program.Delay(5000)

Program.End()

Código Visual Basic graduado

program1

Excel: asignar nombres a celdas o rangos


http://exceltotal.com/asignar-nombres-a-celdas-o-rangos/

Asignar un nombre a un rango de celdas

Estos nombres se pueden utilizar dentro de una fórmula para ayudar en la compresión de la misma posteriormente. Para asignar  un nombre a una celda sigue los siguientes pasos. Selecciona la celda o rango a la que asignarás un nombre y haz clic en el cuadro Nombre que se encuentra en el extremo izquierdo de la barra de fórmulas:

ex1

Escribe el nombre que deseas y presiona Entrar.

ex3

Otra manera de crear un nombre para un rango es desde la ficha Fórmulas y el botón Asignar nombre

ex5

 

Una vez que hayas seleccionado el rango de celdas oprime este botón y se mostrará el cuadro de diálogo Nombre nuevo:

ex6

En la caja de texto Nombre coloca el nombre que asignarás a la celda o rango y oprime el botón Aceptar.

Utilizar un nombre en una fórmula

Como ejemplo final utilizaré el nombre que acabamos de crear dentro de una fórmula para que observes cómo Excel interpreta correctamente el nuevo nombre del rango, observa la barra de fórmulas:

Ex5

Ahora ya sabes que puedes nombrar tanto celdas como rangos y utilizar ese nombre dentro de tus fórmulas para facilitar tu trabajo.

Por Moisés Ortíz el 26 mayo, 2011

Variables


variable

¿Qué es una variable?

Puede utilizar una variable para almacenar diferentes tipos de información, tales como texto o un número. Una variable puede contener diferentes valores en diferentes momentos. La mayoría de las variables sólo pueden contener un valor a la vez. Sin embargo, las variables especiales, llamadas matrices, pueden contener más de un valor. Vamos a ver un programa en el que se crea una variable para almacenar el nombre del usuario.

Una variable temporal almacena un valor que el programa puede usar posteriormente. Si ejecuta el programa de nuevo pero le asigna un valor distinto a la variable, el nuevo valor de la variable reemplazará el valor antiguo.

Al ejecutar un programa también se usa el valor de la variable, tal como se especificó en el código. Puede volver a usar una variable cuantas veces lo necesite en el programa.

Código:

  1. TextWindow.Write(“¿Cómo se llama?”)
  2. nombre = TextWindow.Read()
  3. TextWindow.WriteLine(“Hola” + nombre + “.”)

Código Bisual Baqsic (graduado)

 

variable1

La operación GetRandomNumber (código)


random
En este programa dibujamos la forma ‘*’ en la ventana de gráficos con diferentes tamaños y en diferentes ubicaciones. Primero establecemos
el alto, ancho y color de fondo de la ventana de gráficos. Luego establecemos el tamaño de la fuente con la operación GetRandomNumber.
El tamaño de la fuente será un número entre
1 y 30, ya que especificamos el valor 30 como parámetro de la operación GetRandomNumber.
También empleamos esta misma operación
para establecer las coordenadas X e Y de los asteriscos.
Visual Basic 2010 Express
random1

Controles en pantalla (Código Visual Basic 2010 Express)


controlsPara agregar controles en la pantalla se debe escribir una instrucción que contiene el objeto Controls con una operación adecuada. Veamos el ejemplo en la pantalla:

Primero usamos la operación AddTextBox del objeto Controls para agregar dos cuadros de texto que contienen el nombre del usuario. Debemos especificar las coordenadas X e Y de los cuadros de texto como parámetros.

Luego usamos la operación AddButton para agregar un botón a la ventana de gráficos. Además de las coordenadas X e Y también debemos especificar el título del botón como parámetro.

A continuación usamos la operación AddMultiLineTextBox para agregar otro cuadro de texto. Debemos especificar las coordenadas X e Y del cuadro de texto como parámetros.

En este ejemplo deseamos mostrar un mensaje en el cuadro de texto multilínea cuando se presione el botón Mostrar mensaje. Para esto usamos el evento ButtonClicked y creamos una subrutina para mostrar un mensaje en el cuadro de texto multilínea.

Revise los resultados de su programa haciendo clic en el botón Ejecutar de la barra de herramientas o presionando la tecla F5.

controls1

Text Box (Código Visual Basic)


cajatxtMicrosoft Visual Basic 2010 Express

  • Un programa para mostrar un formulario sencillo, siguiendo los siguientes pasos:
  •   Agrega cajas de texto que acepten el nombre, dirección, número de teléfono y dirección de email del usuario.
  •  Agrega un botón Enviar al formulario.
  •  Una vez que el usuario introduce la información en todas las cajas de texto y hace clic en el botón Enviar, muestre el mensaje correspondiente.

 cajas_txtModule.vb

Module cajas_txtModule

Dim x, y, cuadroTextoNombre, cuadroTextoDirección, cuadroTextoFono, cuadroTextoCorreo, botónEnviar, botónCancelar, nombre, dirección, fono, correo As Primitive

Sub Main()

GraphicsWindow.Show()

GraphicsWindow.Width = 340

GraphicsWindow.Height = 250

GraphicsWindow.Top = (Desktop.Height – 450) / 2

GraphicsWindow.left = (Desktop.Width – 600) / 2

GraphicsWindow.Title = “Formulario”

x = 30

y = 37

‘Escriba el nombre

GraphicsWindow.DrawText(x, y, “Nombre:”)

cuadroTextoNombre = Controls.AddTextBox(150, 35)

Controls.SetSize(cuadroTextoNombre, 150, 20)

‘Dirección

GraphicsWindow.DrawText(x, y + 40, “Dirección:”)

cuadroTextoDirección = Controls.AddMultiLineTextBox(150, 70)

Controls.SetSize(cuadroTextoDirección, 150, 40)

‘Detalles de teléfono

GraphicsWindow.DrawText(x, y + 90, “Teléfono:”)

cuadroTextoFono = Controls.AddTextBox(150, 125)

Controls.SetSize(cuadroTextoFono, 150, 20)

‘Correo electrónico

GraphicsWindow.DrawText(x, y + 125, “Correo electrónico:”)

cuadroTextoCorreo = Controls.AddTextBox(150, 160)

Controls.SetSize(cuadroTextoCorreo, 150, 20)

‘Enviar

botónEnviar = Controls.AddButton(“Enviar”, x + 30, y + 160)

Controls.SetSize(botónEnviar, 90, 30)

‘Cancelar

botónCancelar = Controls.AddButton(“Cancelar”, x + 150, y + 160)

Controls.SetSize(botónCancelar, 70, 30)

AddHandler Controls.ButtonClicked, AddressOf EnviarFormulario

End Sub

Sub EnviarFormulario()

nombre = controls.GetTextBoxText(cuadroTextoNombre)

dirección = controls.GetTextBoxText(cuadroTextoDirección)

fono = controls.GetTextBoxText(cuadroTextoFono)

correo = controls.GetTextBoxText(cuadroTextoCorreo)

If Controls.GetButtonCaption(Controls.LastClickedButton) = CType(“Enviar”, Primitive) Then

If (nombre = CType(“”, Primitive)) or (dirección = CType(“”, Primitive)) or (fono = CType(“”, Primitive)) or (correo = CType(“”, Primitive)) Then

GraphicsWindow.ShowMessage(“Complete todos los cuadros.”, “Mensaje de error”)

Else

GraphicsWindow.ShowMessage(“Sus datos fueron enviados correctamente.”, “¡Enhorabuena!”)

End If

ElseIf Controls.GetButtonCaption(Controls.LastClickedButton) = CType(“Cancelar”, Primitive) Then

Program.End()

End If

End Sub

End Module

Star Field Simulator


star_rain

Graphical Animated Small Basic Program Gallery

     Star Field Simulator  Microsoft Small Basic

     ‘ Program Listing:   GPZ070

  

  1. 5.      ‘ Krueg — Starfield — Sept. 2012

 

  1. 6.      Delay = 60        ‘Delay for smooth framrate
  2. 7.      StarQty = 80      ‘Number of stars, Too many and it slows the program
  3. 8.      SetupWindow()
  4. 9.      CreateStars()

 

  1. 10.  While (“True”)
  2. 11.  MoveStars()
  3. 12.  RefreshRate()   ‘Comment out this line to see the jerkiness of the array proccessing
  4. 13.  EndWhile

 

  1. 14.  Sub RefreshRate
  2. 15.  While Clock.ElapsedMilliseconds < FrameRate
  3. 16.  EndWhile
  4. 17.  FrameRate = Clock.ElapsedMilliseconds + Delay
  5. 18.  EndSub

 

  1. 19.  Sub MoveStars
  2. 20.  For i = 1 To StarQty
  3. 21.  StarY[i] = StarY[i] + StarHeight[i] * 1.5
  4. 22.  If StarY[i] > gh Then
  5. 23.  StarY[i] = StarY[i] – gh
  6. 24.  StarX[i] = Math.GetRandomNumber(gw – 10) + 5
  7. 25.  EndIf
  8. 26.  Shapes.Move(Star[i],StarX[i],StarY[i])      ‘Checking which moves smother, Shapes.Move or Shapes.Animate
  9. 27.  ‘Shapes.Animate(Star[i],StarX[i],StarY[i],0)
  10. 28.  EndFor
  11. 29.  EndSub

 

  1. 30.  Sub CreateStars
  2. 31.  For i = 1 To StarQty
  3. 32.  GraphicsWindow.PenColor = “White”
  4. 33.  GraphicsWindow.BrushColor = “White”
  5. 34.  StarWidth[i] = Math.GetRandomNumber(2)
  6. 35.  If i < (StarQty * .9) Then
  7. 36.  StarHeight[i] = Math.GetRandomNumber(3)   ‘Create more small stars than big
  8. 37.  Else
  9. 38.  StarHeight[i] = Math.GetRandomNumber(4)+4
  10. 39.  EndIf
  11. 40.  Star[i] = Shapes.AddEllipse(StarWidth[i],StarHeight[i])
  12. 41.  Shapes.SetOpacity(Star[i],StarHeight[i]*5+50)
  13. 42.  StarX[i] = Math.GetRandomNumber(gw – 10) + 5
  14. 43.  StarY[i] = Math.GetRandomNumber(gh)
  15. 44.  Shapes.Move(Star[i],StarX[i],StarY[i])
  16. 45.  EndFor
  17. 46.  EndSub

 

  1. 47.  Sub SetupWindow
  2. 48.  gw = 800
  3. 49.  gh = 600
  4. 50.  GraphicsWindow.Top = 5
  5. 51.  GraphicsWindow.Left = 5
  6. 52.  GraphicsWindow.Width = gw
  7. 53.  GraphicsWindow.Height = gh
  8. 54.  GraphicsWindow.BackgroundColor = “Black”
  9. 55.  EndSub

 

  1. 56.  ‘ Copyright (c) Microsoft Corporation. All rights reserved.

Microsoft Excel para la contabilidad


Microsoft Excel es una aplicación de software de hoja de cálculo que puede ser utilizado como una herramienta de contabilidad. Cuando se crea un documento de Excel, se asemeja a una cuadrícula formada por las celdas individuales. Una celda se identifica por su posición en una fila y una columna. Las filas se identifican por su número y las columnas se identifican con una letra. Si una celda es C3, se significa que la celda se encuentra en la fila C y en la tercera columna. Texto, números y cálculos se pueden insertar en la celda individual. Cuando se introduce un cálculo se indica que el programa haga el cálculo con números en las celdas que identificaste. La respuesta aparecerá en la celda en la que se encuentra el cálculo.

Instrucciones

excel1

Agrega una fila de números juntos para obtener la suma total. Puedes insertar la fecha de cada transacción. Si escribes el mes y año, el programa automáticamente lo abrevia. Por ejemplo “Marzo de 2008” se convierte en “Mar-08”. Junto a las fechas, escribe la cantidad de gastos para cada mes. Para agregar una columna, selecciona la fila con el cursor y haz clic en la “Auto-Suma” en la parte superior del menú, que se parece al símbolo ?.

excel2

Suma los totales de los gastos. Por ejemplo, si mantienes una hoja de cálculo con todos tus gastos de electricidad y agua para el año, es posible que desees un total del costo de tus servicios. Haz clic en la celda donde deseas que el total aparezca y se convertirá en el resultado. En la barra de menú, escribe la ecuación. En la foto de ejemplo, escribimos “=B14+E14”. Esto le dice al programa que debe sumar todos los números que están en la celda B14 y la E14.

excel3a

Deduce los gastos de tus ventas. En la foto de ejemplo, los gastos del negocio que tenía la persona sólo eran los servicios públicos y el alquiler. Estos gastos se incluyeron en dos filas y cada fila se ha calculado para dar un total. Los dos totales se añadieron luego juntos. En otra fila hay una lista de las ventas mensuales y la fila en que se sumaron. El programa puede ser instruido para deducir los gastos totales (D15) de las ventas totales (E15) para dar las ventas netas. Si alguna de las cantidades ha cambiado, como el cambio del gasto eléctrico en marzo, de $345 a $400, todos los totales se ajustarán automáticamente para reflejar la cantidad correcta.

De:

http://www.ehowenespanol.com/utilizar-microsoft-excel-contabilidad-como_63636/

Small Basic: Cómo utilizar las funciones trigonométricas


Nonki Takahashi   http://social.technet.microsoft.com/wiki/contents/articles/17744.small-basic-how-to-use-trigonometric-functions.aspx

TechNet Wiki

Imaginemos para dibujar el arco.
Asumir el centro del arco como x = 200, y = 300, comienzo ángulo a1 = -30 y terminar ángulo = -60.
En matemáticas, el eje y va para arriba. Pero en Small Basic Graphicswindow, el eje y desciende. Así, el ágnulo se vuelve opuesto..

trig1

                       

Si usted no utiliza la función trigonométrica de , utilice tan sólo 0, 30, 45, 60, 90…[grados]. Entre estos bordes se puede calcular la altura s de anchura c del triángulo mientras tres ángulos del triángulo r, c, tal como la foto de abajo tiene relación r2 = s2 + c2 .

Pero para cualquier ángulo, utilice la función trigonométrica (seno, coseno).

trig2

Asegúrese de que función trigonométrica necesita [radianes] pero [grados] para el lenguaje Small Basic

Puede utilizar Math.GetRadians(degree) para convertir de [grados] a [radianes].

Siguiendo el ejemplo de código muestra cómo no utilizar o cómo usar las funciones trigonométricas  para dibujar el arco.

gw = GraphicsWindow.Width

gh = GraphicsWindow.Height

DrawGrid()

x = 200

y = 300

r = 200

DrawArcwoTrigo()

Program.Delay()3000)

GraphicsWindow.Clear()

DrawGrid()

a1 = -30

a2 = -60

DrawArcwTrigo()

Sub DrawArcwoTrigo ‘ draw arc without trigonometric functions

GraphicsWindow.Title = “Arc without Trigonometric Functions”

c1 = r * Math.SquareRoot(3) / 2 ‘ a1 = -30

c2 = r / 2 ‘ a2 = -60

r2 = Math.Power(r, 2)

For c = c1 To c2 Step -1

s = Math.SquareRoot()r2 – Math.Power(c, 2))

x2 = x + c

y2 = y – s

If c = c1 Then

GraphicsWindow.PenColor = “Gray”

GraphicsWindow.DrawLine(x, y, x2, y2)

Else

GraphicsWindow.PenColor = “Black”

GraphicsWindow.DrawLine()x1, y1, x2, y2)

EndIf

If c – 1 < c2 Then

GraphicsWindow.PenColor = “Gray”

GraphicsWindow.DrawLine(x, y, x2, y2)

EndIf

x1 = x2

y1 = y2

EndFor

EndSub

Sub DrawArcwTrigo ‘ draw arc with trigonometric functions

GraphicsWindow.Title = “Arc with Trigonometric Functions”

For a = a1 To a2 Step -0.3

x2 = x + r * Math.Cos(Math.GetRadians()a))

y2 = y + r * Math.Sin(Math.GetRadians()a))

If a = a1 Then

GraphicsWindow.PenColor = “Gray”

GraphicsWindow.DrawLine(x, y, x2, y2)

Else

GraphicsWindow.PenColor = “Black”

GraphicsWindow.DrawLine()x1, y1, x2, y2)

EndIf

If a – 0.3 < a2 Then

GraphicsWindow.PenColor = “Gray”

GraphicsWindow.DrawLine(x, y, x2, y2)

EndIf

x1 = x2

y1 = y2

EndFor

EndSub

Sub DrawGrid

GraphicsWindow.PenColor = “MediumSeaGreen”

GraphicsWindow.BrushColor = “MediumSeaGreen”

For _x = 0 To gw Step 50

GraphicsWindow.DrawLine(_x, 0, _x, gh)

If gw – 50 < _x Then

GraphicsWindow.DrawText(_x + 4, 4, “x”)

Else

GraphicsWindow.DrawText(_x + 4, 4, _x)

EndIf

EndFor

For _y = 0 To gh Step 50

GraphicsWindow.DrawLine()0, _y, gw, _y)

If gh – 50 < _y Then

GraphicsWindow.DrawText()4, _y + 4, “y”)

Else

GraphicsWindow.DrawText()4, _y + 4, _y)

EndIf

EndFor

EndSub

 

Cálculo del logaritmo (Visual Basic)


Al hacer cálculos complejos frecuentemente se necesita el valor logarítmico (en base 10) de un número en particular.

El objeto Math de ofrece la operación Log para obtener el logaritmo de un número.

En este ejemplo empleamos la operación Log para calcular el logaritmo de 22.

log1

log

Cálculo de seno y coseno de un ángulo en grados (Visual Basic)


En este ejemplo calculamos el seno y el coseno de un ángulo arbitrario mediante las operaciones Sin y Cos del objeto Math. También obtenemos el ángulo
en radianes a partir del seno mediante la operación ArcSin. A continuación convertimos el ángulo de radianes a
grados con la operación GetDegrees

angulovb

angulo

Small Basic: cálculos matemáticos


math1

¿Le sucede que algunos cálculos matemáticos a veces le llevan demasiado tiempo ? ¡No se preocupe!

El objeto Math ofrece muchas funciones matemáticas que le servirán en sus programas.

Este objeto incluye las siguientes operaciones y propiedades:

math

Objeto  Math
La clase Math (matemáticas) proporciona muchos métodos útiles relacionados con las matemáticas.

Pi Abs ArcCos ArcSin ArcTan Ceiling Cos Floor GetDegrees GetRadians GetRandomNumber Log Max Min NaturalLog Power Remainder Round Sin SquareRoot Tan

Shapes Editor – Small Basic Featured Program


shape

Small Basic  The Official Blog of Small Basic

 

Ed Price – MSFT  Microsoft      From Nonki Takahashi:

What’s New in Shapes 1.42 :

  • Supported cursor key to move a shape.
  • New UI for consecutive shapes addition.
  • Added instruction in save popup.

http://blogs.msdn.com/b/smallbasic/archive/2013/06/14/shapes-editor-small-basic-featured-program.aspx

Small Basic: How to Debug – Featured Article (II)


Small Basic  The Official Blog of Small Basic

Ed Price – MSFT Microsoft

Today’s featured article was written by…Nonki Takahashi

This article includes following tips about how to debug program written in Small Basic language.  And also this article shows you real samples for debugging with published programs.

  • Use TextWindow.WriteLine() to show contents of variables
  • Write debug code such as “If debug Then…”
  • Write test programs for subroutines
  • Write list of bugs
  • Meaning of error messages
  • Use “Graduate” and Visual Studio debugger

Use TextWindow.WriteLine() to show contents of variables

When you find something wrong in you program, how do you find the cause?  Small Basic IDE (integrated development environment) doesn’t have ability such like variable watching.  But in many cases, some variables have unexpected values in them.  To find that, let’s add TextWindow.Write() or TextWindow.WriteLine() to look in variables for debugging.

To show an array “arry”, you can simply use TextWindow.WriteLine(arry) or write code like the following code:

TextWindow.ForegroundColor = “Yellow”

num = Array.GetItemCount(arry)

index = Array.GetAllIndices(arry)

For i = 1 To num

TextWindow.WriteLine(“arry[” + index[i] + “]=” + arry[index[i]])

EndFor

TextWindow.ForegroundColor = “Gray”

For text base program debugging, changing foreground color may help you to distinguish program original outputs and debugging messages.

Write debug code such as “If debug Then…”

If you wrote a subroutine to show such like an array for debug, that code will be useful also in the future.  But, these code will be needed only when you debug.  So it is a way to use debug flag to on and off your debug routines.

Maze 0.4 (PNC833-0) is a sample which has debug flag.  Following line sets debug flag off.  And debug = “True” will turn on the flag.

27.debug = “False”

The following lines call a subroutine to show array “cell” of created maze as text.

61.If debug Then

62.  DumpMaze()

63.  TextWindow.WriteLine(title)

64.EndIf

The following lines slow down creating maze to look and show variables and pause the program using TextWindow.Read().

229.     If debug Then

230.       Program.Delay(20)

231.     EndIf

232.     ‘ 2. Add the neighboring walls of the cell to the wall list.

234.     AddWallToList()

235.     If debug Then

236.       TextWindow.WriteLine(“iWalls=” + iWalls)

237.       TextWindow.Write(“nWalls=” + nWalls)

238.       TextWindow.Read()

239.     EndIf

And after debugging is completed, these lines are easily found (with [Ctrl]+F in Small Basic IDE) and removed.  Actually these routines are removed in Maze 0.5 (not published).

Write test programs for subroutines

To write generic subroutines (for general-purpose) will help your productivity.  In my case, some subroutines for colors, maths, mouse, and etc. are reused in many programs.  But generic subroutines should be well tested and have no bugs.  No (or less) bugs will be a prior condition for productivity.

To test your subroutines, it is a reasonable way to write a test program for them.  Good test program will find bugs from your subroutines and make easy to check regression after debugging.

A program which calculate combination nCr for big n (CPQ608) has a test routine TestDiv() for a generic subroutine Div().

Following parameters were found with TestDiv() and caused problem in Div().

‘a = “434399216531770650390143258708”

‘b = “6752306690329”

‘a = “397896921587794748049229269710”

‘b = “8642083658481”

Write list of bugs

The following list was written when Shapes 1.1 (TLW744) was in debugging.  When you write lots of code, you may happen to meet many strange behaviors in your program.  If so, it will help you that you write a list that includes each phenomenon.  Because there may be many different causes of the phenomena.  And after debugging, this list will be a good test set for your program.

  • CalcOpposite() returns wrong value when shape re-sizing
    cause: variable func was not be set for the routine
  • Pinches (small circles) remain after click out of shapes
    cause: not implemented yet
  • Frame sometimes not appear when shape moving
    cause: variable i didn’t set as selectedshape
  • Pinches sometimes remain when cut and paste
    cause: duplicate as follows
  • Pinches don’t redraw after copy
    cause: pinches are not displayed after paste
  • Shape moves after mouse release
    cause: needed to keep mouse released in mouse handler
  • Other shape size and position become wrong after color change
    cause: unnecessary RegisterShapeData() called and broke variable i
  • Other shape selected after adding ellipse or triangle
    cause: cancel adding procedure (when menu item clicked) set needless variable obj
  • Sometimes shape can’t be moved
    cause: mouse released flag should be cleared

Meaning of error messages

There are two types of error messages given by Small Basic.  One is compile errors.  Another one is runtime errors.  These messages help your development.

Compile errors appear under source code just after “Run” button is clicked if your program has any syntax errors.  The following picture shows errors of a program “Fifty” (BRQ733) :

Sorry, we found some errors…
11,28: The available ‘files’ is used, but its value is not assigned.  Are you sure you have spelled it correctly?
29,24: The available ‘buf’ is used, but its value is not assigned.  Are you sure you have spelled it correctly?

debugging

Numbers mean lines and columns of source code, and you can jump into the point in source program by double clicking the error message.  These kind of compile error messages show you what happened and some advice to fix them. In this case, errors happened because lines with File.GetFiles(path) and File.ReadContents(filename) have been automatically commented out by Small Basic server.

On the other hand, a runtime error appears while a program runs but happens to meet trouble which make the program stop.  Following picture is a sample of divsion by 0 error message.

Decimal type value is too large or too small.
Location System.Decimal..ctor(Double value)
Location Microsoft.SmallBasic.Library.Math.Remainder(Primitive dividend, Primitive divisor)
Location _SmallBasicProgram._Main()

animate1

The list shown in the text box is called stack trace.  This list shows you relations which subroutine calls which subroutine at the error.  In this case, the stack trace shows that main part of the program calls Math.Remainder() and occurs error.

Use “Graduate” and Visual Studio debugger

Despite writing many debug routines, some bugs may be too complicated to find their causes.  As a last option, it will work for you to use “Graduate” button to convert Small Basic program to Visual Basic program.  This allows you to use strong Visual Studio debugger to find causes of bugs originally in your Small Basic program.

Step 1: Install Visual Basic 2010 Express if you don’t install yet.
Step 2: Push “Graduate” button and input folder name for converted Visual Basic program.
Step 3: Push [Next] or [Finish] buttons in Visual Studio conversion wizard.  Program XXX.sb (or XXX.smallbasic) will be converted to XXXModule.vb.
Step 4: Rewrite from ‘For i = 1 To n’ to ‘For i As Primitive = 1 To n’ to avoid scope error.
Step 5: Double click a source line to make the line as break point if needed.
Step 6: Push “Debug Start” button or [F5] key to start program.
Step 7: If program stops at break point, push “Step In (F8)” or “Step Over (Shift+F8)” to continue.
Step 8: See “Auto Variable”, “Local” or “Watch” tab and confirm the values of variables.
Step 9: If you find a bug, push “Stop Debugging” button and rewrite your program with comment.
Step 10: Repeat from step 6 again.

debugging2

If you confirmed a bug fix, go back to Small Basic IDE and fix program just as you did in Visual Studio.

There are some differences between Small Basic and Visual Basic syntax as listed below.

  • Array : Array notation is arry[i][j] in Small Basic but arry(i)(j) in Visual Basic.
  • Variable type : Small Basic variables are type Primitive so sometimes need type conversion such as ‘If ans = CType(“”, Primitive) Then’.
  • Boolean : Type Primitive can be used as boolean as follows:
    clicked = true ‘ or false
    If clicked Then
    If clicked = CType(false, Primitive) Then
  • Array: Setting to two dimensional array doesn’t work in Visual Basic.  So replace ‘shape(5)(“angle”) = 90’ as follows:
    saved = shape(5)
    saved(“angle”) = 90
    shape(5) = saved
  • For block variable: For control variable will cause warning about for it’s scope.  To avoid that declare module name before the variable: (We don’t need to change variables inside block.  Only in For statement.)
    Before: For i = 1 To 10
    After: For FooModule.i = 1 To 10

Conclusion

These tips are outputs from programming Small Basic within the last couple of years but not everything.  It is important to be creative with programming and debugging.  If you find good way, please add the way into this article.  Small Basic is very compact and a good language to learn programming with.   It’s easy and powerful.


Small Basic: How to Debug

How to Create Video Games in VB.Net (Windows Forms) – Code program


vbasicnet

Reed Kimble Micro Plastics, Inc.

http://social.technet.microsoft.com/wiki/contents/articles/17358.how-to-create-video-games-in-vb-net-windows-forms.aspx

I realize that this is a very popular subject, especially amongst budding developers. The drive to create games may be the reason you started working with Visual Basic in the first place. After stepping through a few samples and getting the hang of working with user controls on a form, it may be very tempting to start to throw some PictureBoxes and a Timer on a Form and start to implement some game logic. Seems easy enough, right?

To some extent, this is a true statement. You could start to do this and it would be easy enough… at first. But when you begin to try to calculate collision and animate or rotate your “sprites”, you may start to run into some difficulty. And attempts to circumvent the problems often lead to even worse issues. This can cause an endless spiral of misery which could leave you thinking VB just isn’t meant to make games! 😉

The initial problem that most people face is the desire to use a PictureBox (or any other control) as the logical “Sprite” container for the elements in the game. It makes sense since the control appears to provide a lot of the required functionality already and it’s easy to extend it with more properties as needed.

The issue though is that Windows Forms Controls are designed to be drawn statically – that is, they aren’t meant to move around in real-time. You can of course move them at run-time, but this is normally an on-demand operation (something which occurs because the user just took an action like clicking a button or menu item). Attempting to move controls in real-time puts a heavy strain on your application and can cause poor performance quickly.

There’s also the issue that a control is painted according to its own logic, so you can’t just take any old control and “rotate” it without modifying the logic which draws the control (at some level).

The other thing that Windows Forms leads you right into is using Events. So it’s natural to think to implement user input by handling key and mouse events on the PictureBox or the containing Form. But even though Windows Forms are designed to rely heavily on the Event chain, they are expecting the application to be idle most of the time, doing its work in fits and bursts. This kind of application works well even with many events and handlers.

But a game is a single long-running loop. Your Windows Forms application is technically a pre-specified Form instance started in a long-running message loop, but then you interact with the loop through the Event chain.

For the best performance, a .Net GameEngine should actually do away with the main Form and use the program’s main loop to execute the game loop functionality. But it can be acceptable to maintain the Form and a Control or Component or two and implement a GameEngine in componentized form.

However, this is where the use of controls stops. While there may be a component to house the “GameEngine” related functionality, and a “RenderCanvas” CustomControl to render the game engine display, all of the actual game elements would be class instances handled by the GameEngine component which are not controls of any kind.

Your “Sprite” class (we can debate terminology as technically a sprite is just an image resource, but for this discussion “sprite” is a game object of some sort with image and movement and collision and all) is its own custom “game object” class that you define to hold values such as location, speed, bounds, image and/or animation. The GameEngine is responsible for updating and drawing each game object once each game-loop-iteration and the RenderCanvas is responsible for rendering the last drawn frame.

Here is an example from a thread on the MSDN forums. This very simple example uses a Timer component as the “game engine” and the Form serves as the “render canvas”.

Option Strict On

Public Class Form1

‘One timer controls the entire game loop

Private WithEvents Timer1 As New Timer

‘A list of the game tile objects used by the game

Private _GameTiles As New List(Of GameTile)

‘An instance of GameTime to track running game time

Private _GameTime As New GameTime

‘Two bitmaps and a boolean used to buffer drawing and rendering

Private _Buffer1 As New Bitmap(ClientSize.width, ClientSize.height)

Private _Buffer2 As New Bitmap(_Buffer1.Width, _Buffer1.Height)

Private _BufferFlag As Boolean

Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load

‘setup the form

Me.DoubleBuffered = True

Me.FormBorderStyle = Windows.Forms.FormBorderStyle.Fixed3D

‘load some image assets to use for frames of animation

Dim imageList As New List(Of Image)

imageList.Add(SystemIcons.Application.ToBitmap)

imageList.Add(SystemIcons.Error.ToBitmap)

imageList.Add(SystemIcons.Exclamation.ToBitmap)

imageList.Add(SystemIcons.Information.ToBitmap)

imageList.Add(SystemIcons.Question.ToBitmap)

‘create a grid of tiles

For y As Integer = 0 To 7

For x As Integer = 0 To 7

Dim tile As New GameTile

tile.FrameImages.AddRange(imageList)

tile.Location = New Point(12 + (x * tile.Bounds.Width), 12 + (y * tile.Bounds.Height))

_GameTiles.Add(tile)

Next

Next

‘set the game time to 30 fps (1000ms / 30frames)

Timer1.Interval = 33

‘start the game loop

Timer1.Start()

End Sub

‘Use a stopwatch to track the execution time

Private _ElapsedTime As New Stopwatch

Private Sub Timer1_Tick(sender As Object, e As System.EventArgs) Handles Timer1.Tick

_ElapsedTime.Stop()

‘Record they time since the last loop iteration

_GameTime.Elapse(_ElapsedTime.ElapsedMilliseconds)

‘Reset the stopwatch to 0 and start tracking again

_ElapsedTime.Restart()

‘Run a loop to check input for each item.

For Each tile In _GameTiles

If MouseButtons = Windows.Forms.MouseButtons.Left Then

If tile.Bounds.Contains(PointToClient(MousePosition)) Then

tile.OnInput(_GameTime)

End If

End If

Next

‘Run a loop to draw each item after determining which

‘buffer to draw on this frame

Dim gfx As Graphics

If _BufferFlag Then

gfx = Graphics.FromImage(_Buffer1)

Else

gfx = Graphics.FromImage(_Buffer2)

End If

gfx.Clear(BackColor)

For Each tile In _GameTiles

tile.OnDraw(_GameTime, gfx)

Next

‘Cleanup and swap buffers

gfx.Dispose()

_BufferFlag = Not _BufferFlag

‘Show the drawn scene

Invalidate()

End Sub

Protected Overrides Sub OnPaint(e As System.Windows.Forms.PaintEventArgs)

MyBase.OnPaint(e)

‘Draw the approprite render buffer

If _BufferFlag Then

e.Graphics.DrawImageUnscaled(_Buffer2, Point.Empty)

Else

e.Graphics.DrawImageUnscaled(_Buffer1, Point.Empty)

End If

End Sub

End Class

Public Class GameTile

Public Property Location As Point

Public Property FrameImages As New List(Of Image)

‘this is the images per second of the animation

Public Property FrameRate As Double = 8.0

‘this is the total time to animate after recieving a click

Private _AnimationTime As Double

Public ReadOnly Property Bounds As Rectangle

Get

Return New Rectangle(Location, FrameImages(CurrentFrameIndex).Size)

End Get

End Property

Private _FrameIndex As Double

Public ReadOnly Property CurrentFrameIndex As Integer

Get

Return CInt(Math.Floor(_FrameIndex))

End Get

End Property

Public Sub OnInput(gameTime As GameTime)

‘set the remaining animation time to 3 seconds when clicked

_AnimationTime = 3.0

End Sub

Public Sub OnDraw(gameTime As GameTime, gfx As Graphics)

‘draw the current frame at its current location

gfx.DrawImageUnscaled(FrameImages(CurrentFrameIndex), Location)

‘if there is remaining animation time, then animate

If _AnimationTime > 0 Then

_FrameIndex += gameTime.LastFrame * FrameRate

If CurrentFrameIndex = FrameImages.Count Then _FrameIndex = 0.0

_AnimationTime -= gameTime.LastFrame

Else

_FrameIndex = 0.0

End If

End Sub

End Class

‘GameTime can be a simple structure or class which just tracks executed

‘game time based on what the game loop tells it

Public Structure GameTime

Public ElapsedTime As TimeSpan

Public LastFrame As Double

Public Sub Elapse(milliseconds As Long)

ElapsedTime += TimeSpan.FromMilliseconds(milliseconds)

LastFrame = milliseconds / 1000

End Sub

End Structure

Notice that the code only defines two classes other than the Form. This example defines a single “sprite” or “game object” called GameTile, and a structure called GameTime which is used to track the game engine execution time (both total time and last frame time, that is, last loop iteration time) – an important set of values in many calculations.

The GameTile class is overly-simple and just has an OnInput and OnDraw logic processing routine for the engine to call. In a more robust model, there would be additional logic processing methods which would get called at various appropriate points throughout each execution of the game engine loop.

The GameTile has very simple logic which just executes a 3 second “animation” (sequence of images) played at the frames-per-second specified by FrameRate whenever the tile is clicked.

The game engine loop itself is implemented in the Timer1_Tick event handler. As previously noted, this is not ideal as the event chain is less efficient for our purposes than running a background thread would be, but the timer keeps the example simple. Regardless of where it is run, the logic executed by this Timer1_Tick event handler lays out the general structure of the logic which needs to occur once each game loop iteration.

First, we update the time based on how long the last frame took to execute. You might do this at the end of each iteration, rather than at the beginning, but this implementation does it first because it makes the code simple to follow.

Next we update input for each game object (GameTile). Since the example is running directly off of the Form’s thread we can just cheat on input and read it in real time from the Form. A more robust game loop would maintain an Input object which was updated once per frame before beginning on game objects. So the code checks each object to see if the mouse is being held down on it, and calls the OnInput method for that object if so.

Game objects should have their input updated first, then their logic processed, and finally their positions drawn. It is important to perform separate loops for each operation so that all game objects work together in a predictable manner. This example does not use an OnUpdate method, but typically, OnInput, OnUpdate, and OnDraw are the minimum logic processing methods for a game object.

Now that all of the GameTile objects are updated, they can have their current state drawn. The example does implement buffered drawing even though this simple implementation doesn’t really require it. But it is not very complex and it makes it much more clear how to transition drawing into multiple threads.

By implementing a buffered drawing (do not confuse with DoubleBuffered property of Form – that just makes GDI behave for real-time drawing) we ensure that the image being processing by the Form thread is never the same as the image being processed by the background game engine loop. The Form renders one buffer image and the game loop draws to the other, and then flips buffers as the last operation on each frame. After the buffer has been flipped, a call can be sent off to invalidate the Form (or render control) and the game loop can continue processing and drawing the next frame (on the alternate buffer).

Once the code has selected the correct buffer for drawing this frame, it proceeds to create the graphics object which will be passed to every game object allowing it to draw itself to the buffer. When this process is complete, the graphics can be freed, the buffer can be flipped, and the render control can be informed that it needs to update.

Again, and I can’t stress enough, this is only a most basic implementation – a robust game engine has a lot more work to do. But this example should provide a simple overview of the primary concepts involved with creating a game engine.

XNA

The next most important thing to be aware of when it comes to creating games in VB.Net is that Microsoft has an official platform just for Games and Interactive Software, called XNA Framework . As of the latest refresh you can now use VB with XNA Game Studio. Although XNA can seem quite daunting at first, if you understand the basic concepts lain out above, then you are already well on your way to using it. XNA follows a similar pattern to what I’ve described here, and there are lots of examples and tutorials to get you started. There is just a lot more to it since XNA supports everything – all 2D, 3D, audio, game-pad input, multiplayer networking, Xbox Live access, etc.

Games created in XNA can also easily be written to port from Windows to Xbox to WindowsPhone7. And you can easily become a publisher and actually put your game on Xbox Live or Windows Marketplace and collect royalties for its purchases.

Now, for a fairly simple, very “classic” style 2D video game, XNA could be considered overkill. And what you can accomplish with GDI+ and some creative sound and input hooks might provide everything that your game design requires. But just keep in mind that broad support for game development is available under the XNA platform and it is incredibly powerful once you get the hang of using it (which really isn’t as bad as it first may seem if you just stick with it!).

Unity

I always feel obligated to mention this non-Microsoft-based solution because it is just so dang powerful and cool and wonderful and free (to play with anyway!). Unity3D is a complete 3D development environment; like Visual Studio only the “form designer” is a 3D world space and the toolbox is full of game objects! The AI can be developed through script plugins in multiple languages including C# and Java. So while it’s not exactly a VB solution, I still bring it up because the C# you would need to know is pretty easy to convert from VB and the Unity engine itself is truly remarkable.

In many ways what Unity does is very much like what XNA does. The main difference is that Unity goes so far as to define what a game engine is and then allows you to easily extend it, whereas XNA only provides all of the interfaces necessary for you to create your own game engine of some kind. This is what allows Unity to provide a rich editor full of drag-and-drop and property-grid-setting features.

GdiGaming API

Finally, if you still have your heart set on making a quick little game directly in VB.Net (and why shouldn’t you?! They do make such fun projects!), then you may wish to check out the GdiGaming API over on CodePlex .

This is a project I’m working on as I have time, which is meant to give a robust example of creating game engine in VB.Net using GDI as well as provide a compiled runtime which can be used as-is to quickly make little games based around the engine.

While there may still be a few bugs to work out, the API works generally as intended and is quite powerful for what it does and how it is designed.  The project is a pretty good start on a full-scale game engine based around the kind of example shown above. It is open-source (as CodePlex implies) and I’ve tried to provide fairly rich documentation and sample code. There’s still plenty to do (always a work in progress I guess!) but I believe there is enough there already for it to be of additional help if you are interested in reading more.

Conclusion

I hope that somewhere in all of this there is some useful information for those of you starting out to write games in .Net. The horizons are currently broad, and the roads become more and more well-traveled every day. The amount of information available is tremendous and I would encourage you to play with all of the technologies mentioned in this article and read all of their help files. Even if you don’t download anything yet, just go to the XNA and Untiy websites, navigate to their intro tutorials and read them. Take note of the terminology and get a general feel for what the code appears to do, even if you can’t read all of it.

The next great game is just waiting to be written, and with effort and determination in no short supply you could be the one to write it! =)

en-US, has code, has comment, has comments, VB.NET 2010, Video Games, visual basic, Windows Forms [Edit tags]

Beginning Microsoft Small Basic – Review by “Royal Little Lambs”


a1

Small Basic

The Official Blog of Small BasicMSDN Blogs > Small Basic >

Ed Price – MSFT

Microsoft

MSFT

182,282 Points 25 20 19

Recent Achievements

Better Galleries Together Forums Replies V Proposed Answerer III

Liz reviewed Computer Science for Kids and very much enjoyed learning Beginning Microsoft Small Basic.

There are 11 lessons. They range from 22-109 pages.

The lessons generally consist of

  • Review and preview
  • Small Basic (lessons)
  • Program (application: actual programming)
  • Summary

Liz quickly became very comfortable with the lessons and completed them all by herself and called me {constantly} to come see her fun little creations.
Dad downloaded and set up and looked through the curriculum to see what needed to be done. This was outta Mom’s comfort zone! Liz was bored with waiting.

Then after it was all ready, Dad showed her how to work the program a bit, and she perked up.

Elizabeth loved learning about the history of computers and programming in the first lessons. I was impressed with this narrative.

It shows pictures of the first computers – nifty. And did you know that BASIC is an acronym? (Beginner’s All-Purpose Symbolic Code) From Class 1: “Small Basic starts with a really simple programming language that gathers inspiration from the original BASIC language. It has no more than 15 keywords and is strictly imperative.”

She likes the “games.” She likes the control and learning how changing just one letter or character can change the whole program. Her analytical mind at work! I love that she is learning about computers. I know my dad is proud (it’s what he wanted me to do!).  It’s great help to her in math since she has to calculate the size of shapes or borders within the graphics.

Then she was on her own. She was all proud of herself and showing me all these little “games” she wrote.

She self-corrected her code when they didn’t work just the way she wanted. Dad helped her change them and showed her different options. Then she ran with it.

I am thankful that we can utilize the kids’ desktop computer and my laptop so Liz could have the lessons up and do her code at the same time. It made it less frustrating for her. And that makes me happy.

The true test is that she can explain to me why the shape is filled in or outlined in a certain color and which code is needed to make it do what she wants!

I noticed yesterday that she’s completed all 11 lessons – the whole book…

Me: “If you like it, I will purchase the next book for you.”

Liz: “I thought you already had the whole program for me. I want it all!”

And that’s a good review.

A typical lesson only takes a few minutes (tweaking and playing can take much longer!) so many colors, choices, sizes, codes…it’s like a new toy! She has this last on her daily list as an incentive to complete her other work!

Beginning Microsoft Small Basic

Thanks to Philip Conrod and to Jennifer from Royal Little Lambs.

small basic, Ed Price, Guest Blogger, Philip Conrod, Small Basic E-Books

  •  

     

Visual Basic 2010 Express (código de programa)


letras

Las letras caen una por una (animación) hasta formar la frase: Hello Word 

Código Visual Basic migrado (graduado) de Small Basic

Module UntitledModule

Dim displayText, i, letter, letterShape, j As Primitive

Sub Main()

GraphicsWindow.Show()

GraphicsWindow.BackgroundColor = ” Yellow ”

displayText = “Hello World”

For i = 1 To 11

letter = Text.GetSubText(displayText, i, 1)

letterShape = Shapes.AddText(letter)

For j = 1 To 100

Shapes.Move(letterShape, 20 * i, j)

Program.Delay(10)

Next

Program.Delay(100)

Next

End Sub

End Module

Código Small Basic original:

GraphicsWindow.Show() GraphicsWindow.BackgroundColor = ” Yellow ”

displayText = “Hello World”

For i = 1 To 11

letter = Text.GetSubText(displayText,i,1)

letterShape = Shapes.AddText(letter)

For j = 1 To 100

Shapes.Move(letterShape,20*i,j)

Program.Delay(10)

EndFor

Program.Delay(100)

EndFor

Tareas básicas en Excel 2010


ejecutivos

Entre los escenarios más comunes de uso de Excel se incluyen:

  • Contabilidad Se pueden usar las eficaces características de cálculo de Excel en muchos informes contables y financieros (por ejemplo: estados de flujo de efectivo, balances de ingresos o estados de resultados).
  • Definición de presupuestos Ya sea para necesidades personales o empresariales, puede crear cualquier tipo de presupuesto en Excel (por ejemplo: planes de presupuesto de marketing, presupuestos de eventos o presupuestos de jubilación).
  • Facturación y ventas Excel también es útil para administrar datos de ventas y facturación, y en éste se pueden crear fácilmente los formularios que se necesiten (por ejemplo: facturas de ventas, albaranes u órdenes de compra).
  • Informes Con Excel, se pueden crear diversos tipos de informes para mostrar resúmenes o análisis de datos (por ejemplo: informes que miden el rendimiento de los proyectos, que muestran la variación entre los resultados reales y los proyectados, o que se pueden usar para pronosticar datos).
  • Planeamiento. Excel es una gran herramienta para crear planes profesionales u organizadores útiles (por ejemplo: planes semanales de clases, planes de estudios de marketing, planes de impuestos para fin de año u organizadores para ayudarlo con la planificación de comidas semanales, fiestas o vacaciones).
  • Seguimiento Se puede usar Excel para hacer el seguimiento de los datos en una planilla de horas o en una lista (por ejemplo: planillas de horas para hacer un seguimiento del trabajo o listas de inventario con las que se hace un seguimiento al inventario).
  • Uso de calendarios Gracias a su área de trabajo con cuadrícula, Excel se presta para crear cualquier tipo de calendario (por ejemplo: calendarios académicos para hacer el seguimiento de las actividades durante el año escolar o calendarios del año fiscal para hacer el seguimiento de eventos empresariales e hitos).

En este artí­culo:


  • ¿Qué es Excel?
  • Buscar y aplicar una plantilla
  • Crear un nuevo libro
  • Guardar un libro
  • Escribir datos en una hoja de cálculo
  • Aplicar formato a números
  • Aplicar bordes de celda
  • Crear una tabla de Excel
  • Aplicar sombreado a la celda
  • Filtrar los datos
  • Ordenar los datos
  • Crear una fórmula
  • Realizar un gráfico con los datos
  • Imprimir una hoja de cálculo
  • Activar y usar un complemento

http://office.microsoft.com/es-ar/excel-help/tareas-basicas-en-excel-2010-HA101829993.aspx

Programming Tips : basic and essential for any language programming (code lines in blue)


http://social.technet.microsoft.com/wiki/contents/articles/15081.small-basic-programming-tips.aspx    By litdev Small Basic Forum Moderator

flowchart-for-modeling-data1

 

This article covers the basic ideas of structured programming, or some tips for writing better programs in Small Basic or another language.

‘Better’ is subjective and people do prefer different styles, but there are some general rules that do help, especially when your programs get more complicated.

GoTo

This is the most controversial and opinion differs.

Normally a program runs one line, then the next, progressing through the code in a logical order.  It can do For or While loops and branch into different code using If, ElseIf and EndIf.  The path taken through the code is sometimes called the ‘flow’ of the code.  We want this flow to be as clear and logical as possible.

A GoTo just jumps somewhere completely different.  This can make the code very hard to follow and virtually impossible to debug or extend if they are used indiscriminately.  However, they are a very natural concept for the starting programmer before they know much about other ways to control the flow of code.

Below is a sample code using GoTo’s too much – what is it supposed to do and why doesn’t it work?

x = 0

y = 0

For i = 1 To 100

  a:

  x = x+1

  b:

  x = x-1

  c:

If (i <10) Then

    Goto a

  Else

    y = y+1

    Goto b

  EndIf

  If (y <3) Then

    Goto c

  EndIf

EndFor

These are called ‘spaghetti’ code.

The general rule is for every GoTo that you use, you should consider very carefully if there is a better way to do it – there almost always is.  There are occasions in Small Basic where it is the best option, but they are very rare.

You should never use a GoTo to jump into or out from a subroutine or your program will crash.  This is because the call stack will be corrupted.  The call stack is an internal structure that controls where a subroutine should return to when it ends and is updated when the subroutine is called and returned from.

Subroutines

Subroutines are pieces of code that perform a specific task.  Often the task may be needed in different parts of your code and prevent duplication of code.  If you are writing very similar code for different parts of your program, then probably subroutines could help.

A subroutine in Small Basic starts with the keyword Sub and ends with EndSub.  It can then be called by using the subroutine name followed by two round braces ().

value = Math.Pi

roundResult()

writeOutput()

 

Sub roundResult

  result = 0.001*(Math.Floor(1000*value+0.5))

EndSub

Sub writeOutput

  TextWindow.WriteLine(“the current value rounded to 3 decimals is “+result)

EndSub

The subroutine code block can be placed anywhere in your code, but it is best to place them all together after you main code.

Often we can break a task into a number of sub tasks, each of which could then be a subroutine.

The length of a subroutine is not that important, don’t just subdivide a long piece of code into subroutines unless each has a specific task.  Generally it is good if the main or top-level subroutines are quite short so it is easy to follow the main logic of the program.

The key to subroutines is:

  • Making them do just one task – it may be very general like “Initialise Program” and include many sub tasks or be very specific like “Check overlap of 2 shapes”.  You should be able to describe the subroutine task in just a few words and don’t tempted to ‘just add in a little something else’.
  • Make them as general as possible – especially if you might want to reuse the code in other programs.  See the section on “Variables or constants”.

Comments

A comment in Small Basic starts with an apostrophe ‘ and is highlighted in green.  Anything after it is ignored to the end of the line.

'Calculate distance between objects

distance = Math.SquareRoot((x-a)*(x-a) + (y-b)*(y-b)) '(x,y) is the player

Comments are not just for others reading your code, they help remind you later why you did something.  More importantly they show the thinking behind the code and the ideas about how the program should work.

Try to add comments that explain something complex or why you did something one way or another.  They should remind you and help someone else understand the overall thinking you had when you wrote the program.

The ‘more comments the better’ is not good, the following comment adds nothing.

x = x+5 'Add 5 to x

Sometimes comments can be used to visually separate sections of your code like the start of subroutines.

 

Variable names

Try to use descriptive names for your variables, there is no penalty in performance or memory for long variable names.  Try not to make them too long, but be clear what they are.

There are conventions for variable naming, but most common is to mainly use lower case and capitalise each word apart from the first (that remains lower case).

For loop counters are usually just a single character, i, j, k etc.

playerTank = Shapes.AddImage(playerTankImage)

For i = 1 To numEnemy

  enemyTank[i] = Shapes.AddImage(enemyTankImage)

EndFor

Variables or constants

Sometimes in your code you use a value that is fixed, perhaps the number of enemies, or offset for positioning a shape at its centre or the text used to ask a question.

It is good practice to put all these constants in variables so that you can just change the variable without having to change the constant values throughout your code.  It can also make your code more general so that it can be re-used or subroutines used more extensively, reducing the need for duplicate code.  All the variables can be simply initialised in one subroutine at the start.

GraphicsWindow.Show()

displayText = "Hello World"

For i = 1 To 11

  letter = Text.GetSubText(displayText,i,1)

  letterShape = Shapes.AddText(letter)

  For j = 1 To 100

    Shapes.Move(letterShape,20*i,j)

    Program.Delay(10)

  EndFor

  Program.Delay(100)

EndFor)

The code above would be better written as below so we can easily change the parameters of the method if we change the font for example.

Initialise()

displayText = "Hello World"

ShowText()

 

Sub Initialise

  GraphicsWindow.Show()

  characterOffset = 20

  movingLetterSteps = 100

  delayMovingLetter = 10

  delayLetter = 100

EndSub

Sub ShowText

  For i = 1 To Text.GetLength(displayText)

    letter = Text.GetSubText(displayText,i,1)

    letterShape = Shapes.AddText(letter)

    For j = 1 To movingLetterSteps

      Shapes.Move(letterShape,characterOffset*i,j)

      Program.Delay(delayMovingLetter)

    EndFor

    Program.Delay(delayLetter)

  EndFor

EndSub

 Arrays

Use arrays where possible to group items.  For example if you have multiple buttons, put them all in an array.  In the example below all we need to do to add more buttons is add a new buttonText array element.

Initialise()

Controls.ButtonClicked = OnButtonClicked

 

Sub Initialise

  buttonText[1] = “Clear”

  buttonText[2] = “Start”

  buttonText[3] = “Run”

  buttonText[4] = “Pause”

  buttonText[5] = “Exit”

  numButton = Array.GetItemCount(buttonText)

  

  For i = 1 To numButton

 button[i] = Controls.AddButton(buttonText[i],60*i-50,GraphicsWindow.Height-40)

    Controls.SetSize(button[i],50,30) ‘Equal size to look better

  EndFor

EndSub

 

Sub OnButtonClicked

  lastButton = Controls.LastClickedButton

 For i = 1 To numButton

    If (lastButton = button[i]) Then

      GraphicsWindow.ShowMessage(buttonText[i]+” was clicked”,”Information”)

    EndIf

  EndFor

EndSub

 

Code layout

Indentation and spacing

Use the indentation feature of Small Basic to format your code.  This can be found by right clicking and select ‘Format Program’.

Also use blank lines to separate code segments, but try not to have lots of randomly placed blank lines.

layout

Code order

Place your main code at the start, then place all subroutines below the main code, perhaps separating program subroutines and event subroutines.

Perhaps also separate your main code into sections like ‘Initialisation and Setup’, ‘Main Program’ or others that may apply.

Planning

Try to think of a program structure at the start, then create the main subroutines and variables/arrays and gradually add the detail.  Test detail in small prototype programs first, then add to the main program.

The temptation is to add all the fine detail of a program at the start and then build a structure around this, but this will often lead to code that is hard to develop and debug.

Macro (VBA) para extraer números de una celda


ex1

Algunas semanas atrás publiqué un artículo que utilizaba funciones para extraer números de una celda en Excel. (  http://exceltotal.com/extraer-numeros-de-una-celda-en-excel/  )

Sin embargo, dicho método tiene ciertas restricciones como el hecho de extraer solo el primer bloque de números encontrado en la cadena.

Hoy haremos una macro para extraer todos los números de una celda sin importar su posición dentro de la cadena y para ello utilizaremos la función IsNumeric la cual nos permite saber si el carácter analizado es un valor numérico.

Función IsNumeric en VBA

La función IsNumeric tiene un funcionamiento muy sencillo ya que tiene un solo argumento y que es el valor que deseamos evaluar.

Como resultado obtendremos un valor verdadero (TRUE) en caso de que el argumento sea un valor numérico y un valor falso (FALSE) en caso contrario. Para nuestro ejemplo aplicaremos la función IsNumeric a cada carácter contenido en la celda.

Ver más : http://exceltotal.com/macro-para-extraer-numeros-de-una-celda/?utm_source=rss&utm_medium=rss&utm_campaign=macro-para-extraer-numeros-de-una-celda

Programming Tips – Small Basic Featured Article


smallavisual

Ed Price – MSFT    http://blogs.msdn.com/b/smallbasic/archive/2013/06/10/programming-tips-small-basic-featured-article.aspx

LitDev strikes again with another fantastic article on TechNet Wiki:

Small Basic: Programming Tips

This article covers the basic ideas of structured programming, or some tips for writing better programs in Small Basic.

 Subroutines

Subroutines are pieces of code that perform a specific task.  Often the task may be needed in different parts of your code and prevent duplication of code.  If you are writing very similar code for different parts of your program, then probably subroutines could help.

A subroutine in Small Basic starts with the keyword Sub and ends with EndSub.  It can then be called by using the subroutine name followed by two round braces ().

  1. value = Math.Pi
  2. roundResult()
  3. writeOutput()
  1. Sub roundResult
  2. result = 0.001*(Math.Floor(1000*value+0.5))
  3. EndSub
  1. Sub writeOutput
  2. TextWindow.WriteLine(“the current value rounded to 3 decimals is “+result)
  3. EndSub

The subroutine code block can be placed anywhere in your code, but it is best to place them all together after you main code.

Often we can break a task into a number of sub tasks, each of which could then be a subroutine.

The length of a subroutine is not that important, don’t just subdivide a long piece of code into subroutines unless each has a specific task.  Generally it is good if the main or top-level subroutines are quite short so it is easy to follow the main logic of the program.

The key to subroutines is:

  • Making them do just one task – it may be very general like “Initialise Program” and include many sub tasks or be very specific like “Check overlap of 2 shapes”.  You should be able to describe the subroutine task in just a few words and don’t tempted to ‘just add in a little something else’.
  • Make them as general as possible – especially if you might want to reuse the code in other programs.  See the section on “Variables or constants”.

Excel: Calcular las ventas acumuladas


Las ventas acumuladas del año no son más que la suma de las ventas de los meses anteriores hasta la fecha actual, es decir, una suma acumulada. Un concepto básico y muy  fácil de implementar en Excel.

http://exceltotal.com/calcular-las-ventas-acumuladas/        Sumas acumuladas en Excel

exceltotalSupongamos los siguientes datos de ventas mensuales:

ex1

Insertaré una nueva columna y haré uso de la función SUMA para crear la siguiente fórmula:

ex2

Observa detenidamente el rango de la función SUMA, porque lo estoy escribiendo de manera que al copiar la fórmula hacia abajo obtenga la suma acumulada automáticamente.

En primer lugar estoy indicando a la función que sume un rango que siempre comenzará en la celda B2 y terminará en la celda actual. Es por eso que he colocado el símbolo “$” junto al número 2 para fijar la fila y que no se auto incremente aun cuando copie la fórmula hacia abajo.  Para el caso específico de la celda C2 el rango inicia y termina en la misma celda, pero al copiar la fórmula hacia abajo obtendremos el resultado esperado:

La celda C13 muestra claramente cómo la fórmula mantuvo la referencia a la celda inicial B$2 y realizó la suma hasta la fila correspondiente, que en este caso es la fila 13. Los datos están correctos por ejemplo, para el mes de febrero la columna Acumulado muestra la suma de las ventas de enero y febrero. Para el mes de marzo muestra la suma de las ventas de los primeros 3 meses del año.  Es de esperarse que la última celda de la columna Acumulado muestre la suma de todos los meses del año.

Lo más importante al realizar sumas acumuladas es establecer adecuadamente el rango de suma haciendo buen uso de las referencias absolutas y relativas en Excel.

Calcular el promedio acumulado

Ahora comprueba que has aprendido bien el concepto y agrega una nueva columna para mostrar el promedio de ventas acumulado:

ex4

Tip: Debes utilizar la función PROMEDIO

Ping Pong Small Basic para pequeños (código)


pong

Small Basic   The Official Blog of Small Basic

http://blogs.msdn.com/b/smallbasic/archive/2013/06/10/small-basic-for-little-kids-series-pong.aspx
Versión 2

‘ v2
‘ bounces well, left to right

‘ make background
GraphicsWindow.Width = “700”
GraphicsWindow.Height = “500”

‘set pen
GraphicsWindow.PenColor = “gray”
GraphicsWindow.PenWidth = “50”

‘draw border
GraphicsWindow.DrawRectangle(0,0,700,500)

‘ set brush
GraphicsWindow.BrushColor = “white”

‘ make left goal, size 100, from (0,200) to (0,300)
GraphicsWindow.FillRectangle(0,200,26,100)

‘ make right goal, size 100, from (674,200) to (674,300)
GraphicsWindow.FillRectangle(674,200,26,100)

‘ set brush
GraphicsWindow.BrushColor = “black”

‘ make paddles
GraphicsWindow.FillRectangle(30,220,10,60)
GraphicsWindow.FillRectangle(664,220,10,60)

‘ draw ball
Sub DrawBall
GraphicsWindow.BrushColor = “black”
GraphicsWindow.FillEllipse(BallX,BallY,10,10)
EndSub

‘ erase ball
Sub EraseBall
GraphicsWindow.PenWidth = “2”
GraphicsWindow.BrushColor = “white”
GraphicsWindow.FillEllipse(BallX,BallY,10,10)
GraphicsWindow.PenColor = “white”
GraphicsWindow.DrawEllipse(BallX,BallY,10,10)
EndSub

‘ sleep
Timer.Interval = 1
Timer.Tick = RunGame

StepSize = 2

StepX = StepSize
StepY = 0

BallX=345
‘ BallY=245
BallY=100

LeftWallX = 27
RightWallX = 660

DrawBall()

Sub RunGame
EraseBall()
BallX = BallX + StepX
BallY = BallY + StepY

‘ Hit right wall
If BallX >= RightWallX Then
StepX = -StepSize
EndIf

‘ Hit left wall
If BallX <= LeftWallX Then
StepX = StepSize
EndIf

DrawBall()
EndSub

MS Small Basic- Simple, divertido, Gradual y Social


Ed Price – MSFT

La programación es diversión, otra vez!

Mirosoft Small Basic pone la “diversión” nuevamente dentro de la programación informática. Con un entorno de desarrollo amigable que es muy fácil de dominar, facilita para niños y adultos en el mundo de la programación.

sb1

Simple

Small Basic combina un ambiente agradable con un lenguaje muy sencillo y un conjunto rico y atractivo de bibliotecas para hacer sus programas y juegos pop. En cuestión de pocas líneas de código, usted estará bien en su camino a la creación de su propio juego!

Con un nuevo y revolucionario IntelliSense ®, Small Basic hace escribir código como una brisa.

sb2

Social

Compartir tus programas con tus amigos; que importan los programas publicados y ejecutarlos en su computadora. Utiliza el reproductor de Silverlight, incluso pueden publicar sus juegos en sus blogs y páginas web para que puedan jugar sus creaciones en el navegador.

Gradual

Aprender los conceptos de programación a partir de los fundamentos y subir tu camino. Small Basic se basa en .NET y lo que aprendes aquí podrían aplicarse fácilmente a otros lenguajes como Visual Basic de programación de .NET. Y cuando te gradúas a Visual Basic, puede traer sus programas existentes  mediante una utilidad de conversión incorporada.

Gracias a Vijaye Raji  por el contenido !

No olvides revisar el foro Small Basic:

Small Basic Forum

Cálculo de la TIR con Excel


 

TIR es el acrónimo de Tasa Interna de Retorno (en inglés IRR: Internal Rate o Return) y se refiere a la tasa de rentabilidad que obtenemos de una inversión, al recibir a cambio posteriormente una serie de importes a lo largo de determinados períodos.

El cálculo de la TIR se utiliza para saber si una inversión es aceptable o no (es aceptable si el interés que obtenemos como resultado, es mayor que el interés que obtendríamos si invirtiéramos en otro proyecto).

Puesto que la fórmula de cálculo del TIR puede llegar a ser muy complicada (ver fórmula del TIR),

TIR1

Ft es el Flujo de Caja en el periodo t.
n es el número de periodos.
I es el valor de la inversión inicial.

en la práctica real se hace imprescindible la utilización de aplicaciones informáticas que realicen el cálculo. En este caso, Excel tiene una función que calcula de forma sencilla la TIR.

La TIR en Excel

En Excel, la TIR se calcula con la función TIR

=TIR (valores;[estimar])

  • Valores:  es el rango de      celdas donde están los valores de los cuales se quiere calcular la TIR. Los valores deben estar en el orden correcto y debe haber al menos      un valor positivo (si no es así, la función devuelve un      error). Las inversiones y los flujos de      rentabilidad negativa se ponen con signo negativo.
  • [Estimar]: es opcional y se refiere al      valor que estimamos aproximado a la tasa que obtendremos. Excel utiliza      una técnica iterativa para la que necesita un valor estimado para      iniciarla. Si no se le proporciona, Excel supone un 10 % (0,1).

Uno de los casos más frecuentes de cálculo de la TIR es el representado por la siguiente imagen, en la que podemos ver que la inversión es el primero de los flujos (en negativo, pues es una salida de dinero) y el resto de celdas del rango son los flujos de rentabilidad generados a lo largo de 4 períodos más (se omite el argumento “estimar“):

E3

En la imagen podemos ver como, con una inversión de 100.000 € y consiguiendo 4 flujos de rentabilidad (en 2.013, negativa), obtenemos una TIR del 2%. La interpretación de todo esto es que en 4 años, se ha obtenido una tasa de rentabilidad neta del 2%. Para decidir si es conveniente llevar a cabo el proyecto o la inversión, debemos asegurarnos de que el coste de oportunidad (tipo de interés que podemos conseguir de forma segura en una entidad financiera, por ejemplo) es inferior a dicho 2%. En caso de que la TIR sea inferior a lo que una entidad financiera nos puede remunerar, deberíamos invertir nuestro dinero en dicha entidad y no hacer la inversión.

José Manuel Pomares Medrano

http://temporaexcel.blogspot.com.ar/2011/10/calculo-de-la-tir-con-excel.html

Tabla dinámica en Excel para casos financieros


 

Una tabla dinámica es una hoja de cálculo interactiva que resume rápidamente grandes cantidades de datos usando el formato y los métodos de cálculo que se requiera. En esta tabla se podrá girar los encabezados de fila y columna alrededor del área de los datos principales para lograr distintas presentaciones de los datos fuente.

Se puede actualizar la tabla dinámica a medida que cambian los datos fuente. Como la tabla se encuentra en una hoja de cálculo, podrá integrarse a un modelo de hoja de cálculo mayor mediante el uso de fórmulas estándares.

Una tabla dinámica proporciona una manera fácil de mostrar y analizar información resumida acerca de los datos ya creados en Microsoft EXCEL o en otra aplicación. Por ejemplo una base de datos que contiene los registros de ventas de varios vendedores, puede crear una tabla dinámica que organice y calcule el total de ventas usando las categorías o campos.

Por ejemplo esta vez crearemos en Excel un cuadro de costos, el objetivos es facilitar la búsqueda creando tablas dinámicas en dos partes, detallando y mostrando  el presupuesto y el real dependiendo del tipo de este.

La tabla es la siguiente:

Una tabla dinámica es una hoja de cálculo interactiva que resume rápidamente grandes cantidades de datos usando el formato y los métodos de cálculo que se requiera. En esta tabla se podrá girar los encabezados de fila y columna alrededor del área de los datos principales para lograr distintas presentaciones de los datos fuente.

Se puede actualizar la tabla dinámica a medida que cambian los datos fuente. Como la tabla se encuentra en una hoja de cálculo, podrá integrarse a un modelo de hoja de cálculo mayor mediante el uso de fórmulas estándares.

Una tabla dinámica proporciona una manera fácil de mostrar y analizar información resumida acerca de los datos ya creados en Microsoft EXCEL o en otra aplicación. Por ejemplo una base de datos que contiene los registros de ventas de varios vendedores, puede crear una tabla dinámica que organice y calcule el total de ventas usando las categorías o campos.

Por ejemplo esta vez crearemos en Excel un cuadro de costos, el objetivos es facilitar la búsqueda creando tablas dinámicas en dos partes, detallando y mostrando  el presupuesto y el real dependiendo del tipo de este.

La tabla es la siguiente:E1

Después de crear la tabla hacer el siguiente proceso para crear el cuadro de búsqueda Costos en personal:

  • [Insertar] – [Tabla dinámica]- [Tabla dinámica]

E2

  • Ubicar  el cursor en el cuadro de la opción Tabla o rango y      seleccionar la primera parte del cuadro de presupuestos. En este caso será      Gastos!$B$4:$F$8
  • Seguidamente Seleccionar la opción Nueva hoja de cálculo.
  • Clic en Aceptar

Se mostrará la siguiente vista…

E3

En el lado derecho se mostrará un listado de campos, agregaremos los campos necesarios alas áreas siguientes:

E4

En este caso usaremos solamente el área de filtro del informe y  valores. Arrastrar los campos tal como se muestra a continuación:

  • Personal a Filtro de informe
  • Presupuesto, Real, diferencia ($) y Diferencia (%) al área de      valores.

-Para crear el cuadro de búsqueda Otros costos insertar otra tabla dinámica y agregar los siguientes campos:

  • Costos a Filtro de informe
  • Presupuesto, Real, diferencia ($) y Diferencia (%) al área de      valores.

– Aplicar el siguiente formato a los cuadros de búsqueda para que resulte tal como se muestra a continuación:

E5

Espero que les guste y hasta la próxima.

Para complementar

http://www.gerencie.com/tabla-dinamica-en-excel-para-casos-financieros.html


pmedio

Ed Price – MSFT  El compilador de Small Basic y su enviroment (entorno)  permiten  3  bibliotecas Small Basic plug in (conectarse)  y ampliar las posibilidades de lo que puede hacer desde dentro de Small Basic.

Aquí está una lista de las pequeñas extensiones básicas:

Small Basic extensions Galery

¿Quieres aprender a crear una extensión para Small Basic?

Small Basic: Cómo crear una extensión usando C# – por Liam McSherry

Small Basic: Cómo crear una extensión utilizando VB.NET – por Noah Buscher

¿Utiliza o crea  extensiones para Small Basic ? Aparecen en la galería de extensiones (enlace de arriba)?

¡ Gracias!

-Ed ninja     http://blogs.msdn.com/b/smallbasic/archive/2013/05/31/does-small-basic-support-extensions.aspx

 

Programación, bien desde el principio…!!! (2)


Si ingresamos al link:  http://smallbasic.com/

Tendremos un completo panorama de los múltiples recursos de MS Small Basic

El software se baja en forma gratuita (inglés o español) de:

“A simplified programming language and environment to help teach programming to beginners

http://www.microsoft.com/en-us/download/details.aspx?id=22961

Como está dentro de .NET Framework (como VB.NET y C#) tambien bajamos sin cargo: .Net Framework 3.5SP1

También están disponibles dos tutoriales sin cargo, y en distintos idiomas:

  • Small Basic: Introducción a la programación. Que enseña con claridad los conceptos básicos de programación (variables, ciclos y subrutinas, condiciones y bifurcaciones,  construcción de un videogame sencillo, etc)
  • Curriculum: un tutorial más completo con innumerables programas de ejmplo con el código escrito para que el estudiante los siga con facilidad
  • Es de destacar que Small Basic tiene una función “Graduar” que convierte a este programa en un projecto Visual Basic, listo para ejecutar.

El alumno que se inicie con Small Basic obtendrá a posteriori, una curva de aprendizaje muy corta para lenguajes más complejos como  Visual Basic  y C#, que junto a Small Basic están en el entorno de .NET Framework

Y po sobre todo, es muy divertido…

Vea el tutorial de introducción, en el idioma que elija en

http://msdn.microsoft.com/en-us/ff423682

¿Qué es realmente un programa de ordenador?

Un programa es un conjunto de instrucciones para el ordenador. Dichas instrucciones indican con precisión al ordenador lo que hacer y el ordenador siempre las sigue. Al igual que la gente, los ordenadores sólo siguen instrucciones si se especifican en un idioma o lenguaje que puedan entender. Estos se denominan lenguajes de programación. Hay muchos lenguajes que los ordenadores entienden y Small Basic es uno de ellos.

Imagine una conversación entre usted y un amigo. Usted y su amigo utilizan palabras, organizadas en frases para intercambiar información. De la misma manera, los lenguajes de programación contienen conjuntos de palabras que pueden organizarse en frases para transmitir información al ordenador. Los programas son básicamente grupos de frases (algunas veces unas pocas y otras miles) que, juntas, tienen sentido por igual tanto para el programador como para el ordenador.

Los programas de Small Basic

Un programa típico de Small Basic consiste en un conjunto de instrucciones. Cada línea del programa representa una instrucción y cada instrucción es una orden para el ordenador. Cuando pedimos al ordenador que ejecute un programa de Small Basic, lee la primera instrucción del programa. Entiende lo que le pedimos y ejecuta la instrucción. Una vez que ha ejecutado la primera instrucción, vuelve al programa para leer y ejecutar la segunda instrucción. Y así continúa hasta alcanzar el final del programa. Es entonces cuando nuestro programa termina.

Nuestro segundo programa

Ahora que ya hemos examinado nuestro primer programa, vamos a darle una nota de color.

(Nuestro segundo programa (para el 1º programa busque en: http://www.empiezoinformatica.wordpress.com  )

TextWindow.ForegroundColor = “Yellow”

TextWindow.WriteLine(“Hola mundo”)

sb1

Cuando ejecute el programa anterior, notará que imprime el mismo mensaje que antes (“Hola mundo”) dentro de la ventana de texto (TextWindow), pero esta vez la imprime en amarillo (Yellow) en lugar de en gris.

sb2

Para ello, hemos agregado una nueva instrucción al programa original. Utiliza una nueva palabra ForegroundColor (color de fondo) al que se le asigna “Yellow” (amarillo). Esto significa que se asigna “Yellow” a ForegroundColor. La diferencia entre las operaciones ForegroundColor y WriteLine es que ForegroundColor no admite ningún parámetro y, por tanto, no necesita paréntesis. En su lugar, le sigue un símbolo igual que (=) y una palabra. ForegroundColor se define como una propiedad de TextWindow. He aquí una lista de valores que son válidos para la propiedad ForegroundColor. Reemplace “Yellow” con uno de los siguientes valores y observe los resultados. No se olvide de las comillas ya que son imprescindibles.

El tutorial completo en:   http://msdn.microsoft.com/en-us/ff423682

Programación, bien desde el principio…!!!


La programación

En informática, se define la programación como el proceso de crear aplicaciones para ordenador utilizando lenguajes de programación. De la misma manera que los humanos hablamos y entendemos inglés, español o francés, los ordenadores entienden programas escritos en ciertos lenguajes.

Estos se denominan lenguajes de programación. Al principio sólo había unos pocos lenguajes de programación y eran muy fáciles de aprender y entender. Pero a medida que los ordenadores y el software se han vuelto cada vez más sofisticados, los lenguajes de programación evolucionaron rápidamente, volviéndose cada vez más complejos. El resultado es que los más modernos lenguajes de programación y sus conceptos son bastante difíciles de comprender para un principiante. Esto ha desalentado a muchas personas a aprender o intentar programar.

Small Basic es un lenguaje de programación que está diseñado para hacer la programación muy sencilla, accesible y divertida para los principiantes. El objetivo de Small Basic es romper cualquier barrera y servir de piedra angular para el increíble mundo de la programación.

El entorno de Small Basic

Empecemos con una breve introducción al entorno de Small Basic. Cuando lance SB.exe por primera vez, se encontrará con una ventana parecida a la siguiente figura.

sb1

Este es el entorno de Small Basic, donde escribiremos y ejecutaremos los programas de Small Basic. Este entorno contiene varios elementos distintos identificados con números.

El Editor, identificado con [1], es el lugar donde escribiremos nuestros programas de Small Basic. Cuando abra un programa de ejemplo u otro guardado previamente, aparecerá en el editor. Una vez abierto, puede modificarlo y guardarlo para usos posteriores.

También puede abrir y trabajar con más de un programa a la vez. Cada programa aparecerá en un editor distinto. El editor que contiene el programa en el que está trabajando se denomina editor activo.

La Barra de herramientas, identificada con [2], se utiliza para emitir comandos bien al editor activo o al entorno. Veremos los distintos comandos de la barra de herramientas según vayamos avanzando.

La Superficie, identificada con [3], es el lugar donde se encuentran todas las ventanas del editor.

Nuestro primer programa

Ahora que ya se encuentra familiarizado con el entorno de Small Basic, empecemos a programar en él. Como se indicó anteriormente, el editor es el lugar donde escribiremos nuestros programas. Escriba la siguiente línea en el editor.

TextWindow.WriteLine(“Hola mundo”)

 

Este es nuestro primer programa de Small Basic. Si lo ha tecleado correctamente, verá algo parecido a la siguiente figura.

sb2

Ahora que hemos escrito nuestro primer programa, vamos a ejecutarlo y ver qué pasa. Podemos ejecutar un programa bien haciendo clic en el botón Ejecutar de la barra de herramientas o utilizando la tecla de método abreviado F5 del teclado. Si todo va bien, nuestro programa debería ejecutarse con el resultado siguiente.

sb3

¡Enhorabuena! Acaba de escribir y ejecutar su primer programa de Small Basic. Es cierto que es un programa pequeño y sencillo, ¡pero es un gran paso para convertirse en un verdadero programador informático! Sólo un detalle más antes de crear programas más grandes. Necesita entender qué es lo que hemos hecho. ¿Qué le hemos dicho al ordenador que haga y cómo sabía el ordenador qué hacer? En el siguiente capítulo analizaremos el programa que acabamos de escribir para poder alcanzar dicho entendimiento.

sb4

Guardando nuestro programa

Si desea cerrar Small Basic y volver más tarde al programa que acaba de escribir, tiene que guardarlo. Es una buena práctica guardar los programas de vez en cuando, para no perder ninguna información en el caso de que el ordenador se apague accidentalmente o haya un corte de luz. Puede guardar el programa actual haciendo clic en el icono Guardar de la barra de herramientas o utilizando el método abreviado “CTRL+S” (pulse la tecla “S” mientras mantiene pulsada la tecla CTRL).

http://msdn.microsoft.com/en-us/ff423682

Aplicaciones sencillas en Excel


excel

PLANTILLAS GRATIS PARA MICROSOFT EXCEL

36 visitantes   conectados

// Ningún Iframe

 

PLANTILLAS GRATIS PARA   MICROSOFT EXCEL

 

Excel es la   aplicación más conocida y seguramente, más usada para el cálculo tanto en el   ámbito familiar como profesional.

En este sitio   podrá encontrar plantillas sencillas para Microsoft Excel. Estos archivos   están enfocados para control de stock, ingresos y gastos, facturación,   presupuestos y otros, que podrá descargar de forma gratuita.

 

La idea es   poner a su disposición unas plantillas que le puedan servir para pequeñas   gestiones y que puedan ser modificables en lo posible para que los   internautas puedan adaptarlas a sus necesidades teniendo un mínimo de   conocimientos.

 

También   encontrará un apartado con enlaces web con cursos, utilidades e información   sobre Excel, donde podrá aclarar muchas de sus dudas.

 

http://www.jesusferrer.es/

Uso de las funciones Webservice para actualizar automáticamente hojas de cálculo de Excel con los datos en línea


excel

Excel 2013 – Lee Bizek, director de programas en el equipo de Excel
¿Alguna vez ha querido incorporar datos de recursos en línea en las hojas de cálculo Excel, tales como cotizaciones de bolsa, el tiempo, los resultados de búsqueda de Bing o alimentos incluso Twitter? Con las nuevas funciones Webservice, ahora puede hacerlo.

He utilizado ​​edición anónima en Excel Web para colaborar con un grupo para coordinar un viaje de campamento de 20 personas que requieren algunas personas a dormir en tiendas de campaña al aire libre. Consciente de cambios climáticos en línea nos ayudó a prepararnos para los elementos y también predecir mareas altas y bajas, ya que queríamos ir quejándose como parte de la aventura.
Con Excel 2013 para el escritorio, sacamos la última información meteorológica y la marea de la Internet en Excel utilizando la función WEBSERVICE = (url) – y la mejor parte es la actualización de la información de forma automática!

Con Excel 2013 para el escritorio, sacamos la última información meteorológica y la marea de la Internet en Excel utilizando la función WEBSERVICE = (url) – y la mejor parte es la actualización de la información de forma automática!
Para aprender a utilizar la función Servicio web, haremos 2 cosas:
• Utilice un = function WEBSERVICE (url) para obtener los datos
• Utilice la función = filterXML (xml, xpath) para extraer una sola pieza de los datos de la cadena XML

Vea más en::    http://blogs.office.com/b/microsoft-excel/archive/2013/03/21/add-weather-data-and-other-dynamic-web-content-into-excel-2013-using-webservice-functions.aspx

Small Basic: depuración (debugging) de un programa ( código)


aaaabbbb

Small Basic: TextWindow.WriteLine como ayuda de depuración

¿Cómo detectamos el error? Es hora de depurar el código otra vez…modificar
Puede el programa y usar TextWindow.WriteLine para mostrar el valor que devuelve la operación CopyFile en la ventana de texto – la cual puede ser SUCCESS o FAILED.

De esta manera, si el programa no es capaz de ejecutarse por un error en la operación CopyFile ¡lo sabrá inmediatamente!

Código:

GraphicsWindow.Width = 600

GraphicsWindow.Height = 450

GraphicsWindow.Top = (Desktop.Height-450) / 2

GraphicsWindow.left = (Desktop.Width-600) / 2

GraphicsWindow.Title = “Imágenes”

RutaImagen = “C:\Users\carlos\Pictures\aaaabbbb.jpg”

GUI()

ImagenSmallBasic = File.GetFiles(RutaImagen)

GraphicsWindow.DrawResizedImage(ImagenSmallBasic[i], 50, 50, 500, 300)

Controls.ButtonClicked = SlideShow

Sub GUI

GraphicsWindow.BackgroundColor =”LightSlateGray”

GraphicsWindow.FontSize=25

botónSgte = Controls.AddButton(“<“,50,370)

botónAtr = Controls.AddButton(“>”,500,370)

Controls.SetSize(botónSgte, 50, 50)

Controls.SetSize(botónAtr, 50, 50)

EndSub

Sub SlideShow

If Controls.GetButtonCaption(Controls.LastClickedButton) = “>” Then

If i < Array.GetItemCount(ImagenSmallBasic) Then

i = i + 1

imágenes[i] = ImageList.LoadImage(ImagenSmallBasic[i])

GraphicsWindow.DrawResizedImage(imágenes[i], 50, 50, 500, 300)

TextWindow.WriteLine(“Nombre de imagen: ” + ImagenSmallBasic[i])

EndIf

EndIf

If Controls.GetButtonCaption(Controls.LastClickedButton) = “<” Then

If i > 1 Then

i = i – 1

imágenes[i] = ImageList.LoadImage(ImagenSmallBasic[i])

GraphicsWindow.DrawResizedImage(imágenes[i], 50, 50, 500, 300)

TextWindow.WriteLine(“Nombre de imagen: ” + ImagenSmallBasic[i])

EndIf

EndIf

EndSub

¿Qué lecciones pueden los estudiantes aprender en Small Basic? (Comunidad de Kodu Spotlight: parte 1)


lecciones

MSDN Blogs > Small Basic > ¿Qué lecciones pueden los estudiantes aprender en Small Basic ? (Comunidad de Kodu Spotlight: parte 1  Ed Price – MSFT

Aprenderás los conceptos básicos rápidamente y fácilmente porque lo haráss en el ambiente más simple. BASIC se inició en 1964 y está parado para el código de instrucciones simbólicas multiuso para principiantes. Fue creado para enseñar el desarrollo de software. Así que hemos proporcionado una versión aún más simplificado y más adecuado para conseguir en correr, escribir su propio código y entender conceptos de programación de base, incluso más rápido. Estos conceptos básicos incluyen Variables, condiciones y ramificación, lazos, gráficos, formas, subrutinas, arreglos de discosy eventos & interactividad.

Seguir a uno de nuestros tutoriales, y probablemente a recoger estos conceptos mucho más rápidamente por su cuenta (y aún más rápido con un mentor ayudarle) que lo haría en un aula, donde puede aprender los conceptos por primera vez, en un lenguaje más complicado. Usted aprenderá todos los pilares fundacionales de lenguajes como Visual Basic, C++, C# y muchos más.

En su opinión, ¿cuál es la cosa más fresca sobre Small Basic ?

 

Small Basic fue diseñado originalmente por Vijaye Raji, y su éxito se deriva de los tres pilares del valor.

En primer lugar, es Simple. Small Basic es imperativo y no utilice ni lo exponga a principiantes a conceptos como la orientación a objetos, tipos, alcances, etc.. La lengua se compone de sólo 14 palabras clave. Hay un sistema de tipo. Puede crear cadena y constantes numéricas y asignarlas a variables. Las operaciones realizadas en estas variables se interpretará según el contenido. Todas las variables son globales y se inicializan siempre. Puede ser utilizados antes de que asignó! Puede crear un sub-routine y asignarlo a un evento. Las bibliotecas proporcionan estáticos “objetos” las operaciones del grupo, propiedades y eventos.

Nuevas bibliotecas pueden crearse utilizando otros lenguajes .net y añadidas al tiempo de ejecución pequeño básico. Si eres nuevo en programación, esto no suena muy simple. Muchos de estos detalles son lo que ayuda a hace pequeñas básicas fáciles de aprender y usted puede leer más en Small Basic FAQ

En segundo lugar, es Social. Compartir tus programas con tus amigos; que importar los programas publicados y ejecutarlos en su computadora. Incluso puedes publicar tus juegos en sus blogs y páginas web para que puedan jugar sus creaciones en el navegador! Visita ely Small Basic  program Galery, listados por categoría para ejemplos. Después de colaborar en la fabricación de su juego, puede discutirlo con el
comunidad en el Foro de MSDN básica pequeño. Y entonces nosotros podríamos cuentan en el Blog de MSDN Small Basic.

En tercer lugar, es Gradual. Small Basic se basa en .NET y lo que aprendes aquí podrían aplicarse fácilmente a otros lenguajes como Visual Basic de programación de .NET. Para “graduar” a Visual Basic, simplemente haga clic en el botón graduar, y puede traer sus programas existentes  en Small Basic a Visual Basic mediante la descarga gratuita de Visual Studio Express. Mediante este sistema, usted puede aprender Visual Basic,
C++ y C#, sin jamás gastar un centavo.

Gracias al equipo de producto para la entrevista!

-Ed Price

Excel 2010: OPCIONES DE GRÁFICO


Cuando se pulsa una vez sobre un gráfico, el contorno se transforma en un marco azul con puntos de anclaje para cambiar el tamaño, y tienes acceso a todas las opciones de la ventana de gráfico: Moverlo, borrarlo, modificar el área de datos, copiarlo, cambiar el tipo, etc. Para saber mejor qué puedes hacer, pulsa con el botón derecho sobre el gráfico para obtener el menú contextual.

excel

Herramientas de gráficos

Si señalas el gráfico con el ratón, verás en la parte superior de la pantalla que se te ofrece la ficha de herramientas de gráficos:

excel1

Con ella puedes cambiar rápidamente el diseño del gráfico y los colores, con lo que puede ser que no necesites otros cambios. Si deseas tener más dominio sobre ellos, lee los siguientes párrafos.

Mover el gráfico

Para mover un gráfico señala su borde (aparecerá una cruz) con el ratón, arrastra el gráfico a otra zona y suelta.

http://hojamat.es/guias/guiaexcel/Guia104.pdf

Fácil, divertido, corto e ilustrativo (Código MS Small Basic)


facil

 

Usted puede publicar su código fuente de ejemplo interesante (y una pantalla opcional del programa) aquí. Si es lo suficientemente interesante, vamos Ofrecemos a usted ya su código fuente en nuestros blogs (http://blogs.msdn.com/smallbasic). Aquí hay algo para empezar.

Código:

GraphicsWindow.Show()

pic = Flickr.GetRandomPicture(“lightning”)

gw = GraphicsWindow.Width

gh = GraphicsWindow.Height

GraphicsWindow.DrawResizedImage(pic, 0, 0, gw, gh)

distance = 50

Turtle.Speed = 9

For sides = 3 To 20

DrawPolygon()

EndFor

Sub DrawPolygon

angle = 360 / sides

For i = 1 To sides

GraphicsWindow.PenColor = GraphicsWindow.GetRandomColor()

Turtle.Move(distance)

Turtle.Turn(angle)

EndFor

EndSub

Excel 2010: Mostrar fórmulas en lugar de resultados


Microsoft Excel 2010:  Consejos para principiantes
• Por Jill Duffy, Edward Mendelson

excel

Una sola pulsación permite alternar entre la visualización de Excel normal, que muestra los resultados de las fórmulas de la hoja de cálculo, y un modo de pantalla que muestra las fórmulas reales. El golpe de teclado es Ctrl-tilde (tilde es esta clave: ~), pulse una vez, y Excel muestra las fórmulas en lugar de resultados. Pulse otra vez, y los resultados aparecen de nuevo. Esto solo golpe de teclado es mucho más rápido de usar que el método alternativo de fórmulas que muestran, que es abrir el menú Archivo, vaya a Opciones, Opciones avanzadas y, a continuación, desplácese hacia abajo para ver las opciones para esta hoja de trabajo y marque la casilla junto a “Mostrar fórmulas en celdas en lugar de sus resultados calculados “. Desactive la casilla para mostrar los resultados de nuevo.
Consejo adicional: cuando se utiliza este truco para mostrar fórmulas en las celdas, seleccione una celda con una fórmula, Excel y describe las células que se hace referencia en la fórmula
http://www.pcmag.com/article2/0,2817,2386995,00.asp

Excel 2010: Agregar etiquetas de datos a un gráfico


Excel Total: Puedes agregar etiquetas de datos a un gráfico de Excel para ayudar a identificar los valores mostradas en cada punto de una serie de datos. Excel permite diferentes opciones para la colocación y formato de las etiquetas.

Sigue los siguientes pasos para agregar las etiquetas de datos a tu gráfico. Haz clic sobre cualquier lugar del área del gráfico que deseas modificar y selecciona la ficha Presentación y el comando Etiquetas de datos:

excel1

El menú se muestra con las siguientes opciones:

  • Ninguna. Ésta es la opción      predeterminada y significa que no habrá etiquetas de datos en el gráfico.
  • Centro. Coloca las etiquetas de      datos en el centro de cada punto de datos.
  • Extremo interno.  Posiciona las      etiquetas en el extremo interno superior de los puntos.
  • Base interior. Las etiquetas se      mostrarán en el extremo interior inferior.
  • Extremo externo. Coloca las etiquetas      por fuera de cada punto.

excel2

Selecciona la mejor opción del menú y Excel colocará las etiquetas de inmediato. Para personalizar aún más las etiquetas haz clic en la opción de menú Más opciones de la etiqueta de datos y se mostrará el cuadro de diálogo siguiente:

excel3

Puedes configurar a detalle las etiquetas, inclusive puedes especificar que en lugar del valor la etiqueta muestre el nombre de la serie o de la categoría. Una vez que hallas hecho los cambios apropiados haz clic en el botón Cerrar.

Recuerda que puedes remover fácilmente las etiquetas de datos del gráfico con solo seleccionar la opción Ninguno del menú Etiquetas de datos.

http://exceltotal.com/agregar-etiquetas-de-datos-a-un-grafico/

Excel 2010: Recuperar documentos no guardados


recover
Por Jill Duffy, Edward Mendelson
Word, Excel y PowerPoint tienen una nueva característica que guarda los documentos que usted ha olvidado de guardar cuando se cerró-incluyendo documentos que no se ha molestado en guardar con un nombre más específico que “Documento1”. Esta función se basa en la función de guardado automático de larga data de la Oficina, que realiza automáticamente copias de seguridad de la versión actual del documento cada diez minutos (o cualquier intervalo que usted configuró en las opciones de la aplicación). Las versiones anteriores de Office borrados la última de estas copias de seguridad automatizadas al cerrar un documento, pero Office 2010 conserva la última copia de seguridad automática y permite abrirlo. Haga clic en Archivo, Recientes, recuperar documentos no guardados y, a continuación, seleccione el documento a partir de un cuadro de diálogo estándar Abrir archivo /.
-Siguiente consejo: Mostrar fórmulas en lugar de resultados>

http://www.pcmag.com/article2/0,2817,2386994,00.asp

Tablas Excel: Filtro de títulos de la tabla


Jill Duffy, Edward Mendelson

 filter_excel

 

Cuando se crea una tabla en Excel, ahora se puede hacer clic en la flecha hacia abajo en la celda de encabezado y utilizar el menú situado en la parte superior izquierda de la misma, para filtrar la pantalla, es decir, puede mostrar sólo las filas que contienen subtotales y totales , o una o más filas específicas que seleccione marcando una casilla en una lista.

Puede mostrar sólo las filas que coinciden con un color de fondo específico, o utilizar las casillas de verificación para mostrar u ocultar las filas individuales

http://www.pcmag.com/article2/0,2817,2386993,00.asp

Introducción: Windows Workflow Foundation y ASP.NET


Windows Workflow Foundation es una gran tecnología para crear flujos de trabajo. Puede ser utilizado en combinación con diferentes tecnologías, por ejemplo, SharePoint, WCF, etc.. En este artículo se combinará el Windows Workflow Foundation con ASP.NET.

Tabla de Contenidos

El escenario

Para mantener las cosas fáciles, creamos una aplicación muy simple saludo. El usuario se escriba su nombre en un cuadro de texto, haga clic en un botón, y aparecerá un saludo con su nombre. ¿Suena simple? ¡ Es!

Archivo – nuevo – proyecto

Empiece creando un vacío solución Visual del estudio:

aspnet

El nombre lo que quieras. Ahora añadiremos dos proyectos para esta solución – una aplicación Web de ASP.NET vacío (Workflow.Web) y una Biblioteca de actividad (WorkflowLibrary).

asp1

asp2

Configurarlo

En el lado de nuestro flujo de trabajo

Por ahora, simplemente elimine el archivo Activity1.xaml.

En el lado de nuestro sitio web

Crear un nuevo formulario Web y asígnele el nombre  Default.aspx:

asp3

Necesitamos cuatro controles en nuestro sitio:

  • Una etiqueta, que sólo muestra “su nombre:”; no más funcionalidad
  • Un cuadro de texto donde el usuario puede escribir su nombre
  • Un botón, que activará el flujo de trabajo
  • Una etiqueta que muestra el resultado del flujo de trabajo, nuestro saludo

El código es espectacular; sólo necesita un evento click en el botón de control:

<%@ Page Language=”C#” AutoEventWireup=”true” CodeBehind=”Default.aspx.cs” Inherits=”Workflow.Web.Default” %>

html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”&gt;

xmlns=”http://www.w3.org/1999/xhtml”&gt;
<title></title>
</head>
<body>
server”>
<div>
<asp:Label Text=”Your name: ” runat=”server” />
<asp:TextBox ID=”TextBoxName” runat=”server” />
<asp:Button ID=”ButtonCreateGreeting” Text=”Create greeting” runat=”server”
onclick=”ButtonCreateGreeting_Click” />
<br />
<asp:Label ID=”LabelGreeting” Text=”” runat=”server” />
</div>
</form>
</body>
</html>

 

continúa en español en:    http://social.technet.microsoft.com/wiki/contents/articles/5284.getting-started-windows-workflow-foundation-and-asp-net.aspx?CommentPosted=true#commentmessage

Ultima revisión:  Carsten Siemens  Capgemini  Socio    07/05/2013 23:02

Pilas y matrices en programación (explicación y código)


matriz                       pila

Trabajo de litdev (Scotland) Moderador Small Basic Forum

http://social.technet.microsoft.com/wiki/contents/articles/15066.small-basic-stack-basics.aspx

Queremos crear una matriz con todos los archivos de imagen jpg de un directorio y todos los subdirectorios, buscando todas las carpetas de forma recursiva.
Primero creamos un array (matriz) vacío para almacenar las rutas de los archivos de imagen y el número de archivos en el mismo (cero para empezar). También establecemos la carpeta de empezar a buscar y agregarlo a una pila que llamamos “folders” (carpetas). En este ejemplo, la ubicación de la carpeta de inicio es la carpeta donde está guardado el archivo Small Basic fuente (Program.Directory

images = “”

imageCount = 0

startFolder = Program.Directory

Stack.PushValue(“folders”,startFolder)

Ahora vamos a seguir trabajando mientras nosotros tenemos carpetas todavía para comprobar, o la pila todavía tiene algunas carpetas en el mismo. Nosotros usamos un bucle while para esto. Dentro del bucle, mientras que nosotros queremos  procesar la última carpeta añadida, por lo que se metió primero

While Stack.GetCount(“folders”) > 0

currentFolder = Stack.PopValue(“folders”)

‘ More work to do here

EndWhile

Ahora queremos procesar esta carpeta, primero tenemos todas las subcarpetas, de la carpeta de trabajo actual y empujar a estos en la pila para su posterior comprobación de que las while repite.

folders = File.GetDirectories(currentFolder)

For i = 1 To Array.GetItemCount(folders)

Stack.PushValue(“folders”,folders[i])

EndFor

Después de haber añadido las sub-carpetas para comprobar más tarde como se desenrolla la pila, nos encontramos con todos los archivos en la carpeta de trabajo actual y añadir otras que terminan en “. Jpg” a la lista de Array (matriz). Comprobamos el archivo por primera conversión a minúsculas, con el fin de incluir todas las variantes de caja de jpg a JPG etc

files = File.GetFiles(currentFolder)

For i = 1 To Array.GetItemCount(files)

fileName = files[i]

fileNameLower = Text.ConvertToLowerCase(fileName)

If (Text.EndsWith(fileNameLower,”.jpg”)) Then

imageCount = imageCount+1

images[imageCount] = fileName

EndIf

EndFor

 

Por último, imprimir los resultados, y por ahora es todo.

 

images = “”

imageCount = 0

startFolder = Program.Directory

Stack.PushValue(“folders”,startFolder)

While Stack.GetCount(“folders”) > 0

currentFolder = Stack.PopValue(“folders”)

folders = File.GetDirectories(currentFolder)

For i = 1 To Array.GetItemCount(folders)

Stack.PushValue(“folders”,folders[i])

EndFor

files = File.GetFiles(currentFolder)

For i = 1 To Array.GetItemCount(files)

fileName = files[i]

fileNameLower = Text.ConvertToLowerCase(fileName)

If (Text.EndsWith(fileNameLower,”.jpg”)) Then

imageCount = imageCount+1

images[imageCount] = fileName

EndIf

EndFor

EndWhile

For i = 1 To Array.GetItemCount(images)

TextWindow.WriteLine(images[i])

EndFor

Excel 2010: Abrir varias hojas de cálculo con un doble clic


excel

Hablando de varias ventanas, a veces se trabaja en dos o más hojas de cálculo independientes al mismo tiempo, cada uno en una ventana separada, y usted sabe que  desea trabajar en el mismo conjunto de hojas de trabajo,  de nuevo mañana.

Por lo tanto, antes de cerrar Excel, vaya al menú Ver y haga clic en Guardar área de trabajo cerca de la parte derecha de la cinta. En el cuadro de diálogo Guardar espacio de trabajo, escriba un nombre y una ubicación para los valores de vista guardados, y un icono de espacio de trabajo guardado se crea en la ubicación que elija, tal vez su escritorio. Si desea abrir el mismo conjunto de hojas de trabajo, sólo tiene que hacer doble clic en el icono del área de trabajo guardada.

By Jill Duffy, Edward Mendelson

http://www.pcmag.com/article2/0,2817,2386992,00.asp