Jeremy Wall

Jeremy Wall is a musician, and along with Jay Beckenstein, was a founding member of the jazz fusion band Spyro Gyra. He contributed to the group as a pianist, producer, and composer. He is currently an assistant professor in the Music Industry department at SUNY Oneonta.[1]

Jeremy Wall
GenresJazz
InstrumentsPiano
Associated actsSpyro Gyra

Background

Wall formed Spyro Gyra in the mid-1970s with classmate Jay Beckenstein. Although each took time off to attend college, the band stayed intact. Wall attended Columbia University, then moved to Buffalo where Beckenstein was attending college. Wall then moved to California to attend California Institute of the Arts, graduating with a B.F.A. in Music Composition. He later received an M.M. in Studio Composition from Purchase College in 2001. He has recorded extensively as producer, keyboardist, composer and arranger in all genres of music and has released over 70 of his own compositions. Wall has also been nominated for several Grammys as a producer, pianist and composer. His composition “Shakedown” was nominated for a Grammy award for “Best Pop Instrumental.” He was the featured soloist at the Shenandoah Bach Festival in 2004.[2]

Wall worked as an adjunct professor at both Ramapo and Purchase College before joining SUNY Oneonta, where he teaches courses relating to contemporary issues in the music industry and songwriting. He also leads the jazz funk band. These classes draw upon Wall's history with Spyro Gyra and his experience in the music industry.

Currently

Wall, along with the SUNY Oneonta Funk Band ensemble, often plays music on campus and in the surrounding area.

Discography

  • Cool Running (Amherst, 1991)
  • Stepping Into the New World (Amherst, 1992)

With Spyro Gyra

With Richard Stoltzman

  • 1991 Brasil
  • 1991 Begin Sweet World
  • 1992 Hark!
  • 1995 Visions
  • 1994 Dreams
  • 1996 Spirits
  • 1998 Danza Latina
  • 1998 Open Sky
  • 2000 World Beat Bach

With others

gollark: See, this is much nicer.
gollark: ```rustpub struct List<T> { head: Link<T>,}type Link<T> = Option<Box<Node<T>>>;struct Node<T> { elem: T, next: Link<T>,}impl<T> List<T> { pub fn new() -> Self { List { head: None } } pub fn push(&mut self, elem: T) { let new_node = Box::new(Node { elem: elem, next: self.head.take(), }); self.head = Some(new_node); } pub fn pop(&mut self) -> Option<T> { self.head.take().map(|node| { self.head = node.next; node.elem }) }}impl<T> Drop for List<T> { fn drop(&mut self) { let mut cur_link = self.head.take(); while let Some(mut boxed_node) = cur_link { cur_link = boxed_node.next.take(); } }}```
gollark: ... or at all?
gollark: You don't have a thing to efficiently deallocate the list.
gollark: Collections which work on a big chunk of memory or something *do* kind of have to use unsafe, linked lists or (some?) trees mostly don't.

References


This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.